[eclipsethinslicer.git] / Svelte / src / edu / berkeley / cs / bodik / svelte / slicers / JavaLanguage.java
| blob | 5dfff6fa37dcccfa6fe40c9469f7703f7f1a8c84 |
71 /**
72 * A slicer that handles Java code by using CAST's Java support
73 *
74 * @author DarkWulf
75 */
79 /**
80 *
81 * @author DarkWulf
82 */
91 // initialize the SvelteAnalysisEngine with appropriate entry points
96 // if no launchers for project, try open editor's className anyway.
97 // the user may get the
98 // idea...
104 }
106 /**
107 * Retrieves the class name of a given file.
108 *
109 * Since this ignores position we will never get an inner class from this, so the code
110 * you're looking for may be in another class file.
111 *
112 * @param file
113 * @return the fully qualified class name for the file
114 */
119 }
121 /**
122 * If the SourcePosition selects a formal parameter in a method declaration, return the
123 * parameter index, starting at 0. If it finds a parameter, also (should but can't since we
124 * can't get the document in this thread) sets the line numbers of the beginning of the
125 * function to make sure we can find the method in WALA's CGNode. Also uses selectAndReveal
126 * to select the whole parameter (hack) if necessary
127 *
128 * @param position
129 * @param editor
130 * @return Parameter index of -1 if position does not correspond to a selected or
131 * partially-selected parameter
132 */
134 // get AST
138 // get covering node
142 // ascend the tree until we find a method.
151 // set position's line number
160 }
164 }
166 }
169 }
171 @Override
174 }
176 @Override
179 }
181 /**
182 * Look at the Java application launchers for a given project and determine all main
183 * classes.
184 *
185 * @param project
186 * @return List<String> where each element is the fully qualified name of each entrypoint
187 * listed in the project's launchers
188 */
201 // check if it really has a main method. TODO: this only works for source. maybe take this out.
209 }
210 }
211 }
212 }
215 }
217 }
219 @Override
231 }
233 @Override
240 "Could not build call graph, probably due to an internal error. Check console output for more info.");
242 }
246 // check if we have selected a parameter.
247 // do this first, in changes position so we can find the method (if the declaration
248 // spans multiple lines)
255 // Shrike-loaded class don't have source file information. Compare based on
256 // fully-qualified class name.
257 // TODO: this doesn't find correct class name for an inner class.
258 // We have to use the JDT AST to see what the innermost class/interface is.
265 }
269 "Could not find a method containing the line number of code you have selected. It may be that:\n1) You have selected something outside of a method \n2) The source file is out-of-date and needs to be saved\n3) The method is not reachable from the program entrypoints");
271 }
286 "The statement you have selected as a seed is null in the intermediate representation. This probably means that the statement has been optimized away, as in the case of simple assignment statements (\"x=y\"). Please choose another statement where the value in the assignement statement originated from.");
288 }
289 }
290 }
293 // swap out invoke instructions for their return values
302 else
307 "Could not find a suitable seed to slice from. It may be that:\n1) You have selected something that evaluates to a constant\n2) The statement selected has been optimized out (i.e., simple assignment statements)\n3) The source file is out-of-date and needs to be saved");
310 }
312 /**
313 * Some variables may not have statements at that line, e.g. assume foo, a, b, c, and d are
314 * locals: Then they will not have defining statements in 'foo.bar(a[b],c+d)', but their
315 * value numbers are used directly.
316 *
317 * Given a source position, if a simple name is selected, this function changes position
318 * to the the statement that uses the simple name and returns the index of the use.
319 *
320 * For example, let's say the user selects 'b' above: then position will be changed to the position
321 * of 'a[b]' and the return value will be 1 (i.e. we should look at use 1 in the WALA arrayload instruction).
322 *
323 * To accomplish this, we look at the context of the node referenced by position - i.e., the type of its parent node
324 * and its location in the parent node.
325 *
326 * @param position
327 * This variable is changed to the match parent node --the instruction that we should find in the IR,
328 * using the return value as the index into the uses of this instruction
329 * @param cgn
330 * @return
331 */
336 // get AST
340 // get covering node
344 // walk down any parentheses to get to the real expression to check if it is a
345 // simplename
352 // get rid of any parentheses above, so the next parent will be the actual parent.
353 // e.g. "(((foo))).bar" -> get to the outermost paren so parent will be
354 // qualifedexpression
367 }
368 substatementIndex++;
369 }
380 }
385 // don't look at extended operands, if there are any.
386 // also, JDT conversion uses start of left operand, not start of infix expression (difference?)
388 position.offsetEnd = ie.getRightOperand().getStartPosition() + ie.getRightOperand().getLength();
392 position.offsetEnd = ie.getRightOperand().getStartPosition() + ie.getRightOperand().getLength();
394 // extended operand
395 substatementIndex = 1; // it will always be the second operand, since we add operands to the right hand side
396 // the trick is determining the position: from the start of the first expression to the end of this expression
398 // position.offsetEnd same
399 }
405 // if varargs, args are boxed first, so we have to deal with that.
412 // if the nActuals != nFormals, it's definitely a varargs invocation. If
413 // nActuals == nFormals, however, we have to check the type of the last argument.
414 // if the last argument is an array type of the correct type, it will be passed in and not boxed.
416 if ( nActuals > 0 && arguments.get(nActuals-1) instanceof Expression ) // if nActuals=0 then it's definitely varargs and nFormals != 0
419 if ( nActuals != nFormals || lastArgType.isSubTypeCompatible(binding.getParameterTypes()[nFormals-1]) ) {
427 // argIndex - nFormals is
428 }
429 // ELSE:
430 // one of the previous, regular args in a varargs invocation.
431 // be very sure to look at invocation instructions only (don't look at the new/array store instructions before it)
432 }
433 }
444 // "bar(a,b,c)" -> a is index 0
445 }
446 }
450 // case 1: "a[b] = c" -> WALA statement covers whole thing (putfield) EXCEPT
451 // PARENTHESES (due to WALA/polyglot bug)!
456 // case 2: "a[b].c = d" (select a) or "a[b]"
457 // covers just a.b
460 }
468 // it will be a FIELD_ACCESS in the case if parentheses: (foo).bar = 5
469 // it will be a QUALIFIED_NAME otherwise: foo.bar = 5
476 // case 1: "a.b = c" -> WALA statement covers whole thing (putfield)
477 // EXCEPT PARENTHESES (due to WALA/polyglot bug)!
482 // case 2: "a.b.c = d" (select a) or "a.b" -- getfield, WALA statement
483 // or foo = a.b
484 // covers just a.b
487 }
489 }
493 // slice on value of right hand side
495 // go past parentheses to get to the real value
500 }
501 // else
502 // right hand side, give warning
504 }
507 // selectAndReveal the actual simple name token to clarify what we are slicing
508 // on. this is kind of a hack
512 parentInstructionClass);
514 }
517 }
522 // System.out.println(covering.getParent().getNodeType());
524 // if ( covering.getNodeType() == ASTNode.)
525 // if covering node is a simple identifier
526 // check parent type:
527 // if the parent is a binop, getfield, putfield, invokevirtual, invokestatic, array
528 // load/store, new Bla[x][y],...
529 // get the "index".
530 // it would be nice to add more safety here in case JDT AST & WALA statements don't
531 // match up exactly
532 // return 0;
533 }
537 @Override
541 length);
543 }
545 }
547 @Override
551 }
552 }
554 @Override
557 }
559 /**
560 * JavaSlicer can handle files with the .java extension
561 */
562 @Override
565 }
566 }