@Override
public void visitBinaryExpression(final BinaryExpression expression) {
boolean assignment =
StaticTypeCheckingSupport.isAssignment(expression.getOperation().getType());
boolean isDeclaration = expression instanceof DeclarationExpression;
Expression leftExpression = expression.getLeftExpression();
Expression rightExpression = expression.getRightExpression();
if (isDeclaration && leftExpression instanceof VariableExpression) {
VariableExpression var = (VariableExpression) leftExpression;
if (Modifier.isFinal(var.getModifiers())) {
declaredFinalVariables.add(var);
}
}
leftExpression.visit(this);
inAssignment = assignment;
rightExpression.visit(this);
inAssignment = false;
if (assignment) {
if (leftExpression instanceof Variable) {
boolean uninitialized = isDeclaration && rightExpression == EmptyExpression.INSTANCE;
recordAssignment(
(Variable) leftExpression, isDeclaration, uninitialized, false, expression);
}
}
}
public void visitVariableExpression(VariableExpression expression) {
String name = expression.getName();
Variable v = checkVariableNameForDeclaration(name, expression);
if (v == null) return;
expression.setAccessedVariable(v);
checkVariableContextAccess(v, expression);
}
public void visitMethodCallExpression(MethodCallExpression call) {
if (call.isImplicitThis() && call.getMethod() instanceof ConstantExpression) {
ConstantExpression methodNameConstant = (ConstantExpression) call.getMethod();
Object value = methodNameConstant.getText();
if (!(value instanceof String)) {
throw new GroovyBugError(
"tried to make a method call with a non-String constant method name.");
}
String methodName = (String) value;
Variable v = checkVariableNameForDeclaration(methodName, call);
if (v != null && !(v instanceof DynamicVariable)) {
checkVariableContextAccess(v, call);
}
if (v instanceof VariableExpression || v instanceof Parameter) {
VariableExpression object = new VariableExpression(v);
object.setSourcePosition(methodNameConstant);
call.setObjectExpression(object);
ConstantExpression method = new ConstantExpression("call");
method.setSourcePosition(methodNameConstant); // important for GROOVY-4344
call.setImplicitThis(false);
call.setMethod(method);
}
}
super.visitMethodCallExpression(call);
}
private List<PropertyNode> findTags(ClassNode classNode) {
List<PropertyNode> tags = new ArrayList<PropertyNode>();
List<PropertyNode> properties = classNode.getProperties();
List<PropertyNode> potentialAliases = new ArrayList<PropertyNode>();
for (PropertyNode property : properties) {
if (property.isPublic()) {
Expression initialExpression = property.getInitialExpression();
if (initialExpression instanceof ClosureExpression) {
ClosureExpression ce = (ClosureExpression) initialExpression;
Parameter[] parameters = ce.getParameters();
if (parameters.length <= 2) {
tags.add(property);
// force Closure type for DefaultGrailsTagLibClass
property.setType(CLOSURE_CLASS_NODE);
}
} else if (initialExpression instanceof VariableExpression) {
potentialAliases.add(property);
}
}
}
for (PropertyNode potentialAlias : potentialAliases) {
VariableExpression pe = (VariableExpression) potentialAlias.getInitialExpression();
String propertyName = pe.getName();
PropertyNode property = classNode.getProperty(propertyName);
if (property != null && tags.contains(property)) {
potentialAlias.setType(CLOSURE_CLASS_NODE);
tags.add(potentialAlias);
}
}
return tags;
}
public Expression transformVariableExpression(VariableExpression expr) {
// we need to transform variable expressions that go to a delegate
// to a property expression, as ACG would loose the information
// in processClassVariable before it reaches any makeCall, that could
// handle it
Object val = expr.getNodeMetaData(StaticTypesMarker.IMPLICIT_RECEIVER);
if (val == null) return expr;
VariableExpression implicitThis = new VariableExpression("this");
// GRECLIPSE start
// Expressions positions should be added to make it possible to recognize correct AST nodes
// later
ConstantExpression ce = new ConstantExpression(expr.getName());
ce.setStart(expr.getStart());
ce.setEnd(expr.getEnd());
PropertyExpression pexp = new PropertyExpression(implicitThis, ce);
pexp.setStart(expr.getStart());
pexp.setEnd(expr.getEnd());
// GRECLIPSE end
pexp.copyNodeMetaData(expr);
pexp.setImplicitThis(true);
ClassNode owner = expr.getNodeMetaData(StaticCompilationMetadataKeys.PROPERTY_OWNER);
if (owner != null) {
implicitThis.putNodeMetaData(StaticTypesMarker.INFERRED_TYPE, owner);
implicitThis.putNodeMetaData(StaticTypesMarker.IMPLICIT_RECEIVER, val);
}
return pexp;
}
// Return false if the inference is illegal. Currently this only happens if the var is reassigned
// to incompatible
// type inside the loop.
public boolean add(VariableExpression ve, ClassNode type) {
if (defVars == null) defVars = FHashMap.emptyMap;
if (ve.getAccessedVariable() != null) {
defVars = defVars.put(ve.getAccessedVariable(), type);
// dumpMap(ve);
} else {
boolean done = false;
for (Map.Entry<Variable, ClassNode> variable : defVars.entrySet()) {
if (variable.getKey().getName().equals(ve.getName())) {
defVars = defVars.put(variable.getKey(), type);
// dumpMap(ve);
done = true;
break;
}
}
if (!done) {
defVars = defVars.put(ve, type);
// dumpMap(ve);
}
}
if (parentScopeInference != null && parentScopeInference.defVars != null) {
final ClassNode oldType = parentScopeInference.defVars.get(ve.getAccessedVariable());
if (oldType != null) {
if (!TypeUtil.isDirectlyAssignableFrom(oldType, type)) {
return false;
}
}
}
return true;
}
public void testPrimitiveOriginTypeConstructorParameter() {
Parameter boolParameter = new Parameter(ClassHelper.boolean_TYPE, "foo");
Parameter intParameter = new Parameter(ClassHelper.int_TYPE, "foo");
VariableExpression newBoolExpression = new VariableExpression(boolParameter);
VariableExpression newIntExpression = new VariableExpression(intParameter);
assertEquals(newBoolExpression.getOriginType().getName(), "boolean");
assertEquals(newIntExpression.getOriginType().getName(), "int");
}
public void testPrimitiveOriginTypeConstructorVariableExpression() {
VariableExpression boolExpression = new VariableExpression("foo", ClassHelper.boolean_TYPE);
VariableExpression intExpression = new VariableExpression("foo", ClassHelper.int_TYPE);
VariableExpression newBoolExpression = new VariableExpression(boolExpression);
VariableExpression newIntExpression = new VariableExpression(intExpression);
assertEquals(newBoolExpression.getOriginType().getName(), "boolean");
assertEquals(newIntExpression.getOriginType().getName(), "int");
}
private ClassNode getConstructorArgumentType(Expression arg, ConstructorNode node) {
if (!(arg instanceof VariableExpression)) return arg.getType();
VariableExpression vexp = (VariableExpression) arg;
String name = vexp.getName();
for (Parameter param : node.getParameters()) {
if (param.getName().equals(name)) {
return param.getType();
}
}
return vexp.getType();
}
/**
* a property on "this", like this.x is transformed to a direct field access, so we need to check
* the static context here
*
* @param pe the property expression to check
*/
private void checkPropertyOnExplicitThis(PropertyExpression pe) {
if (!currentScope.isInStaticContext()) return;
Expression object = pe.getObjectExpression();
if (!(object instanceof VariableExpression)) return;
VariableExpression ve = (VariableExpression) object;
if (!ve.getName().equals("this")) return;
String name = pe.getPropertyAsString();
if (name == null || name.equals("class")) return;
Variable member = findClassMember(currentClass, name);
if (member == null) return;
checkVariableContextAccess(member, pe);
}
@Override
public void visitBlockStatement(final BlockStatement block) {
Set<VariableExpression> old = declaredFinalVariables;
declaredFinalVariables = new HashSet<VariableExpression>();
super.visitBlockStatement(block);
if (callback != null) {
Map<Variable, VariableState> state = getState();
for (VariableExpression declaredFinalVariable : declaredFinalVariables) {
VariableState variableState = state.get(declaredFinalVariable.getAccessedVariable());
if (variableState == null || variableState != VariableState.is_final) {
callback.variableNotAlwaysInitialized(declaredFinalVariable);
}
}
}
declaredFinalVariables = old;
}
public ClassNode get(VariableExpression ve) {
if (defVars == null) return ClassHelper.OBJECT_TYPE;
else {
final Variable accessed = ve.getAccessedVariable();
if (accessed != null) return defVars.get(accessed);
else {
for (Map.Entry<Variable, ClassNode> variable : defVars.entrySet()) {
if (variable.getKey().getName().equals(ve.getName())) {
return variable.getValue();
}
}
return null;
}
}
}
// TODO handle local variables
private void checkForFinal(final Expression expression, VariableExpression ve) {
Variable v = ve.getAccessedVariable();
boolean isFinal = isFinal(v.getModifiers());
boolean isParameter = v instanceof Parameter;
if (isFinal && isParameter) {
addError("Cannot assign a value to final variable '" + v.getName() + "'", expression);
}
}
private boolean doAssignmentToLocalVariable(String method, BinaryExpression binExp) {
Expression left = binExp.getLeftExpression();
if (left instanceof VariableExpression) {
VariableExpression ve = (VariableExpression) left;
Variable v = ve.getAccessedVariable();
if (v instanceof DynamicVariable) return false;
if (v instanceof PropertyExpression) return false;
/* field and declaration we don't return false */
} else {
return false;
}
evaluateBinaryExpression(method, binExp);
getController().getOperandStack().dup();
getController().getCompileStack().pushLHS(true);
binExp.getLeftExpression().visit(getController().getAcg());
getController().getCompileStack().popLHS();
return true;
}
private void checkFinalFieldAccess(Expression expression) {
if (!(expression instanceof VariableExpression) && !(expression instanceof PropertyExpression))
return;
Variable v = null;
if (expression instanceof VariableExpression) {
VariableExpression ve = (VariableExpression) expression;
v = ve.getAccessedVariable();
} else {
PropertyExpression propExp = ((PropertyExpression) expression);
Expression objectExpression = propExp.getObjectExpression();
if (objectExpression instanceof VariableExpression) {
VariableExpression varExp = (VariableExpression) objectExpression;
if (varExp.isThisExpression()) {
v = currentClass.getDeclaredField(propExp.getPropertyAsString());
}
}
}
if (v instanceof FieldNode) {
FieldNode fn = (FieldNode) v;
/*
* if it is static final but not accessed inside a static constructor, or,
* if it is an instance final but not accessed inside a instance constructor, it is an error
*/
boolean isFinal = fn.isFinal();
boolean isStatic = fn.isStatic();
boolean error =
isFinal && ((isStatic && !inStaticConstructor) || (!isStatic && !inConstructor));
if (error)
addError(
"cannot modify"
+ (isStatic ? " static" : "")
+ " final field '"
+ fn.getName()
+ "' outside of "
+ (isStatic ? "static initialization block." : "constructor."),
expression);
}
}
private void dumpMap(VariableExpression ve) {
System.out.print(ve.getName());
System.out.print(" ");
System.out.print(defVars.size());
System.out.print(" ");
for (Map.Entry<Variable, ClassNode> variable : defVars.entrySet()) {
System.out.print(variable.getKey().getName());
System.out.print("->");
System.out.print(variable.getValue().getNameWithoutPackage());
System.out.print(",");
}
System.out.println();
}
@Override
public void visitVariableExpression(final VariableExpression expression) {
super.visitVariableExpression(expression);
if (inAssignment) {
Map<Variable, VariableState> state = getState();
Variable key = expression.getAccessedVariable();
VariableState variableState = state.get(key);
if (variableState == VariableState.is_uninitialized) {
variableState = VariableState.is_var;
state.put(key, variableState);
}
}
}
protected Expression transformVariableExpression(VariableExpression ve) {
Variable v = ve.getAccessedVariable();
if (v != null && v instanceof DynamicVariable) {
Expression result = findStaticFieldOrPropAccessorImportFromModule(v.getName());
if (result != null) {
setSourcePosition(result, ve);
if (inAnnotation) {
result = transformInlineConstants(result);
}
return result;
}
}
return ve;
}
public void evaluateEqual(BinaryExpression expression, boolean defineVariable) {
AsmClassGenerator acg = controller.getAcg();
CompileStack compileStack = controller.getCompileStack();
OperandStack operandStack = controller.getOperandStack();
Expression rightExpression = expression.getRightExpression();
Expression leftExpression = expression.getLeftExpression();
ClassNode lhsType =
controller.getTypeChooser().resolveType(leftExpression, controller.getClassNode());
if (defineVariable
&& rightExpression instanceof EmptyExpression
&& !(leftExpression instanceof TupleExpression)) {
VariableExpression ve = (VariableExpression) leftExpression;
BytecodeVariable var =
compileStack.defineVariable(
ve, controller.getTypeChooser().resolveType(ve, controller.getClassNode()), false);
operandStack.loadOrStoreVariable(var, false);
return;
}
// let's evaluate the RHS and store the result
ClassNode rhsType;
if (rightExpression instanceof ListExpression && lhsType.isArray()) {
ListExpression list = (ListExpression) rightExpression;
ArrayExpression array =
new ArrayExpression(lhsType.getComponentType(), list.getExpressions());
array.setSourcePosition(list);
array.visit(acg);
} else if (rightExpression instanceof EmptyExpression) {
rhsType = leftExpression.getType();
loadInitValue(rhsType);
} else {
rightExpression.visit(acg);
}
rhsType = operandStack.getTopOperand();
boolean directAssignment = defineVariable && !(leftExpression instanceof TupleExpression);
int rhsValueId;
if (directAssignment) {
VariableExpression var = (VariableExpression) leftExpression;
if (var.isClosureSharedVariable() && ClassHelper.isPrimitiveType(rhsType)) {
// GROOVY-5570: if a closure shared variable is a primitive type, it must be boxed
rhsType = ClassHelper.getWrapper(rhsType);
operandStack.box();
}
// ensure we try to unbox null to cause a runtime NPE in case we assign
// null to a primitive typed variable, even if it is used only in boxed
// form as it is closure shared
if (var.isClosureSharedVariable()
&& ClassHelper.isPrimitiveType(var.getOriginType())
&& isNull(rightExpression)) {
operandStack.doGroovyCast(var.getOriginType());
// these two are never reached in bytecode and only there
// to avoid verifyerrors and compiler infrastructure hazzle
operandStack.box();
operandStack.doGroovyCast(lhsType);
}
// normal type transformation
if (!ClassHelper.isPrimitiveType(lhsType) && isNull(rightExpression)) {
operandStack.replace(lhsType);
} else {
operandStack.doGroovyCast(lhsType);
}
rhsType = lhsType;
rhsValueId = compileStack.defineVariable(var, lhsType, true).getIndex();
} else {
rhsValueId = compileStack.defineTemporaryVariable("$rhs", rhsType, true);
}
// TODO: if rhs is VariableSlotLoader already, then skip crating a new one
BytecodeExpression rhsValueLoader = new VariableSlotLoader(rhsType, rhsValueId, operandStack);
// assignment for subscript
if (leftExpression instanceof BinaryExpression) {
BinaryExpression leftBinExpr = (BinaryExpression) leftExpression;
if (leftBinExpr.getOperation().getType() == Types.LEFT_SQUARE_BRACKET) {
assignToArray(
expression,
leftBinExpr.getLeftExpression(),
leftBinExpr.getRightExpression(),
rhsValueLoader);
}
compileStack.removeVar(rhsValueId);
return;
}
compileStack.pushLHS(true);
// multiple declaration
if (leftExpression instanceof TupleExpression) {
TupleExpression tuple = (TupleExpression) leftExpression;
int i = 0;
for (Expression e : tuple.getExpressions()) {
VariableExpression var = (VariableExpression) e;
MethodCallExpression call =
new MethodCallExpression(
rhsValueLoader, "getAt", new ArgumentListExpression(new ConstantExpression(i)));
call.visit(acg);
i++;
if (defineVariable) {
operandStack.doGroovyCast(var);
compileStack.defineVariable(var, true);
operandStack.remove(1);
} else {
acg.visitVariableExpression(var);
}
}
}
// single declaration
else if (defineVariable) {
rhsValueLoader.visit(acg);
operandStack.remove(1);
compileStack.popLHS();
return;
}
// normal assignment
else {
int mark = operandStack.getStackLength();
// to leave a copy of the rightExpression value on the stack after the assignment.
rhsValueLoader.visit(acg);
TypeChooser typeChooser = controller.getTypeChooser();
ClassNode targetType = typeChooser.resolveType(leftExpression, controller.getClassNode());
operandStack.doGroovyCast(targetType);
leftExpression.visit(acg);
operandStack.remove(operandStack.getStackLength() - mark);
}
compileStack.popLHS();
// return value of assignment
rhsValueLoader.visit(acg);
compileStack.removeVar(rhsValueId);
}
public void testNonPrimitiveOriginType() {
VariableExpression boolExpression = new VariableExpression("foo", ClassHelper.Boolean_TYPE);
VariableExpression intExpression = new VariableExpression("foo", ClassHelper.Integer_TYPE);
assertEquals(boolExpression.getOriginType().getName(), "java.lang.Boolean");
assertEquals(intExpression.getOriginType().getName(), "java.lang.Integer");
}
private boolean isThisTraitReceiver(final VariableExpression var) {
return Traits.THIS_OBJECT.equals(var.getName());
}
private boolean isStaticTraitReceiver(final ClassNode receiver, final VariableExpression var) {
return Traits.STATIC_THIS_OBJECT.equals(var.getName())
&& isClassClassNodeWrappingConcreteType(receiver);
}
private void declare(VariableExpression vex) {
vex.setInStaticContext(currentScope.isInStaticContext());
declare(vex, vex);
vex.setAccessedVariable(vex);
}
protected Expression transformMethodCallExpression(MethodCallExpression mce) {
Expression args = transform(mce.getArguments());
Expression method = transform(mce.getMethod());
Expression object = transform(mce.getObjectExpression());
boolean isExplicitThisOrSuper = false;
boolean isExplicitSuper = false;
if (object instanceof VariableExpression) {
VariableExpression ve = (VariableExpression) object;
isExplicitThisOrSuper =
!mce.isImplicitThis() && (ve.isThisExpression() || ve.isSuperExpression());
isExplicitSuper = ve.isSuperExpression();
}
if (mce.isImplicitThis() || isExplicitThisOrSuper) {
if (mce.isImplicitThis()) {
Expression ret = findStaticMethodImportFromModule(method, args);
if (ret != null) {
setSourcePosition(ret, mce);
return ret;
}
if (method instanceof ConstantExpression && !inLeftExpression) {
// could be a closure field
String methodName = (String) ((ConstantExpression) method).getValue();
ret = findStaticFieldOrPropAccessorImportFromModule(methodName);
if (ret != null) {
ret = new MethodCallExpression(ret, "call", args);
setSourcePosition(ret, mce);
return ret;
}
}
} else if (currentMethod != null && currentMethod.isStatic() && isExplicitSuper) {
MethodCallExpression ret =
new MethodCallExpression(
new ClassExpression(currentClass.getSuperClass()), method, args);
setSourcePosition(ret, mce);
return ret;
}
if (method instanceof ConstantExpression) {
ConstantExpression ce = (ConstantExpression) method;
Object value = ce.getValue();
if (value instanceof String) {
String methodName = (String) value;
boolean lookForPossibleStaticMethod = !methodName.equals("call");
if (currentMethod != null && !currentMethod.isStatic()) {
if (currentClass.hasPossibleMethod(methodName, args)) {
lookForPossibleStaticMethod = false;
}
}
if (!inClosure
&& (inSpecialConstructorCall
|| (lookForPossibleStaticMethod
&& currentClass.hasPossibleStaticMethod(methodName, args)))) {
StaticMethodCallExpression smce =
new StaticMethodCallExpression(currentClass, methodName, args);
setSourcePosition(smce, mce);
return smce;
}
}
}
}
MethodCallExpression result = new MethodCallExpression(object, method, args);
result.setSafe(mce.isSafe());
result.setImplicitThis(mce.isImplicitThis());
result.setSpreadSafe(mce.isSpreadSafe());
result.setMethodTarget(mce.getMethodTarget());
// GROOVY-6757
result.setGenericsTypes(mce.getGenericsTypes());
setSourcePosition(result, mce);
return result;
}
protected Expression transformMethodCallExpression(MethodCallExpression mce) {
Expression args = transform(mce.getArguments());
Expression method = transform(mce.getMethod());
Expression object = transform(mce.getObjectExpression());
boolean isExplicitThisOrSuper = false;
if (object instanceof VariableExpression) {
VariableExpression ve = (VariableExpression) object;
isExplicitThisOrSuper =
!mce.isImplicitThis() && (ve.getName().equals("this") || ve.getName().equals("super"));
}
if (mce.isImplicitThis() || isExplicitThisOrSuper) {
if (mce.isImplicitThis()) {
Expression ret = findStaticMethodImportFromModule(method, args);
if (ret != null) {
// GRECLIPSE add
if (!((StaticMethodCallExpression) ret).getMethod().equals(method.getText())) {
// store the identifier to facilitate organizing static imports
ret.setNodeMetaData("static.import.alias", method.getText());
}
// GRECLIPSE end
setSourcePosition(ret, mce);
return ret;
}
if (method instanceof ConstantExpression && !inLeftExpression) {
// could be a closure field
String methodName = (String) ((ConstantExpression) method).getValue();
ret = findStaticFieldOrPropAccessorImportFromModule(methodName);
if (ret != null) {
ret = new MethodCallExpression(ret, "call", args);
setSourcePosition(ret, mce);
return ret;
}
}
}
if (method instanceof ConstantExpression) {
ConstantExpression ce = (ConstantExpression) method;
Object value = ce.getValue();
if (value instanceof String) {
String methodName = (String) value;
boolean lookForPossibleStaticMethod = !methodName.equals("call");
if (currentMethod != null && !currentMethod.isStatic()) {
if (currentClass.hasPossibleMethod(methodName, args)) {
lookForPossibleStaticMethod = false;
}
}
if (inSpecialConstructorCall
|| (lookForPossibleStaticMethod
&& currentClass.hasPossibleStaticMethod(methodName, args))) {
StaticMethodCallExpression smce =
new StaticMethodCallExpression(currentClass, methodName, args);
setSourcePosition(smce, mce);
return smce;
}
}
}
}
MethodCallExpression result = new MethodCallExpression(object, method, args);
result.setSafe(mce.isSafe());
result.setImplicitThis(mce.isImplicitThis());
result.setSpreadSafe(mce.isSpreadSafe());
result.setMethodTarget(mce.getMethodTarget());
// GROOVY-6757
result.setGenericsTypes(mce.getGenericsTypes());
setSourcePosition(result, mce);
return result;
}
public void testIsDynamicTyped_DYNMAMIC_TYPE() {
VariableExpression intExpression = new VariableExpression("foo", ClassHelper.DYNAMIC_TYPE);
assertTrue(intExpression.isDynamicTyped());
}
public void testIsDynamicTypedExplizitObject() {
VariableExpression intExpression = new VariableExpression("foo", new ClassNode(Object.class));
assertFalse(intExpression.isDynamicTyped());
}
protected ClassNode createClosureClass(ClosureExpression expression, int mods) {
ClassNode classNode = controller.getClassNode();
ClassNode outerClass = controller.getOutermostClass();
MethodNode methodNode = controller.getMethodNode();
String name =
classNode.getName()
+ "$"
+ controller
.getContext()
.getNextClosureInnerName(
outerClass, classNode, methodNode); // add a more informative name
boolean staticMethodOrInStaticClass = controller.isStaticMethod() || classNode.isStaticClass();
Parameter[] parameters = expression.getParameters();
if (parameters == null) {
parameters = Parameter.EMPTY_ARRAY;
} else if (parameters.length == 0) {
// let's create a default 'it' parameter
Parameter it = new Parameter(ClassHelper.OBJECT_TYPE, "it", ConstantExpression.NULL);
parameters = new Parameter[] {it};
Variable ref = expression.getVariableScope().getDeclaredVariable("it");
if (ref != null) it.setClosureSharedVariable(ref.isClosureSharedVariable());
}
Parameter[] localVariableParams = getClosureSharedVariables(expression);
removeInitialValues(localVariableParams);
InnerClassNode answer =
new InnerClassNode(classNode, name, mods, ClassHelper.CLOSURE_TYPE.getPlainNodeReference());
answer.setEnclosingMethod(controller.getMethodNode());
answer.setSynthetic(true);
answer.setUsingGenerics(outerClass.isUsingGenerics());
answer.setSourcePosition(expression);
if (staticMethodOrInStaticClass) {
answer.setStaticClass(true);
}
if (controller.isInScriptBody()) {
answer.setScriptBody(true);
}
MethodNode method =
answer.addMethod(
"doCall",
ACC_PUBLIC,
ClassHelper.OBJECT_TYPE,
parameters,
ClassNode.EMPTY_ARRAY,
expression.getCode());
method.setSourcePosition(expression);
VariableScope varScope = expression.getVariableScope();
if (varScope == null) {
throw new RuntimeException(
"Must have a VariableScope by now! for expression: " + expression + " class: " + name);
} else {
method.setVariableScope(varScope.copy());
}
if (parameters.length > 1
|| (parameters.length == 1
&& parameters[0].getType() != null
&& parameters[0].getType() != ClassHelper.OBJECT_TYPE
&& !ClassHelper.OBJECT_TYPE.equals(parameters[0].getType().getComponentType()))) {
// let's add a typesafe call method
MethodNode call =
answer.addMethod(
"call",
ACC_PUBLIC,
ClassHelper.OBJECT_TYPE,
parameters,
ClassNode.EMPTY_ARRAY,
new ReturnStatement(
new MethodCallExpression(
VariableExpression.THIS_EXPRESSION,
"doCall",
new ArgumentListExpression(parameters))));
call.setSourcePosition(expression);
}
// let's make the constructor
BlockStatement block = new BlockStatement();
// this block does not get a source position, because we don't
// want this synthetic constructor to show up in corbertura reports
VariableExpression outer = new VariableExpression("_outerInstance");
outer.setSourcePosition(expression);
block.getVariableScope().putReferencedLocalVariable(outer);
VariableExpression thisObject = new VariableExpression("_thisObject");
thisObject.setSourcePosition(expression);
block.getVariableScope().putReferencedLocalVariable(thisObject);
TupleExpression conArgs = new TupleExpression(outer, thisObject);
block.addStatement(
new ExpressionStatement(new ConstructorCallExpression(ClassNode.SUPER, conArgs)));
// let's assign all the parameter fields from the outer context
for (Parameter param : localVariableParams) {
String paramName = param.getName();
ClassNode type = param.getType();
if (true) {
VariableExpression initialValue = new VariableExpression(paramName);
initialValue.setAccessedVariable(param);
initialValue.setUseReferenceDirectly(true);
ClassNode realType = type;
type = ClassHelper.makeReference();
param.setType(ClassHelper.makeReference());
FieldNode paramField =
answer.addField(paramName, ACC_PRIVATE | ACC_SYNTHETIC, type, initialValue);
paramField.setOriginType(ClassHelper.getWrapper(param.getOriginType()));
paramField.setHolder(true);
String methodName = Verifier.capitalize(paramName);
// let's add a getter & setter
Expression fieldExp = new FieldExpression(paramField);
answer.addMethod(
"get" + methodName,
ACC_PUBLIC,
realType.getPlainNodeReference(),
Parameter.EMPTY_ARRAY,
ClassNode.EMPTY_ARRAY,
new ReturnStatement(fieldExp));
}
}
Parameter[] params = new Parameter[2 + localVariableParams.length];
params[0] = new Parameter(ClassHelper.OBJECT_TYPE, "_outerInstance");
params[1] = new Parameter(ClassHelper.OBJECT_TYPE, "_thisObject");
System.arraycopy(localVariableParams, 0, params, 2, localVariableParams.length);
ASTNode sn = answer.addConstructor(ACC_PUBLIC, params, ClassNode.EMPTY_ARRAY, block);
sn.setSourcePosition(expression);
correctAccessedVariable(answer, expression);
return answer;
}
public void testIsDynamicTyped_DynamicVariable() {
VariableExpression intExpression = new VariableExpression(new DynamicVariable("foo", false));
assertTrue(intExpression.isDynamicTyped());
}
@Override
public List<ICompletionProposal> computeCompletionProposals(
final ContentAssistInvocationContext context, final IProgressMonitor monitor) {
final List<ICompletionProposal> list = new ArrayList<ICompletionProposal>();
boolean extendContext = false;
try {
if (context instanceof JavaContentAssistInvocationContext) {
final ITextViewer viewer = context.getViewer();
final List<ScriptVariable> scriptVariables = getScriptVariables(viewer);
if (scriptVariables.isEmpty()) {
return list;
}
final CompletionContext coreContext =
((JavaContentAssistInvocationContext) context).getCoreContext();
if (coreContext != null && !coreContext.isExtended()) {
// must use reflection to set the fields
ReflectionUtils.setPrivateField(
InternalCompletionContext.class, "isExtended", coreContext, true);
extendContext = true;
}
final ICompilationUnit unit =
((JavaContentAssistInvocationContext) context).getCompilationUnit();
if (unit instanceof GroovyCompilationUnit) {
if (((GroovyCompilationUnit) unit).getModuleNode() == null) {
return Collections.emptyList();
}
final ContentAssistContext assistContext =
new GroovyCompletionProposalComputer()
.createContentAssistContext(
(GroovyCompilationUnit) unit,
context.getInvocationOffset(),
context.getDocument());
CharSequence prefix = null;
try {
prefix = context.computeIdentifierPrefix();
} catch (final BadLocationException e) {
BonitaStudioLog.error(e);
}
if (assistContext != null && assistContext.completionNode instanceof VariableExpression) {
try {
final VariableExpression expr = (VariableExpression) assistContext.completionNode;
if (scriptVariables != null) {
for (final ScriptVariable f : scriptVariables) {
if (expr.getName().equals(f.getName())) {
final IType type = javaProject.findType(f.getType());
if (type == null) {
return list;
}
for (final IMethod m : type.getMethods()) {
if (m.getElementName().startsWith(prefix.toString())) {
final GroovyCompletionProposal proposal =
new GroovyCompletionProposal(
CompletionProposal.METHOD_REF, context.getInvocationOffset());
proposal.setName(m.getElementName().toCharArray());
proposal.setCompletion(
m.getElementName().substring(prefix.length()).toCharArray());
proposal.setFlags(m.getFlags());
if (prefix.length() == m.getElementName().length()) {
proposal.setReplaceRange(
context.getInvocationOffset(), context.getInvocationOffset());
proposal.setReceiverRange(0, 0);
} else {
proposal.setReplaceRange(
context.getInvocationOffset() - prefix.length(),
context.getInvocationOffset());
proposal.setReceiverRange(prefix.length(), prefix.length());
}
final char[][] parametersArray =
new char[m.getParameterNames().length][256];
final List<Parameter> parameters = new ArrayList<Parameter>();
for (int i = 0; i < m.getParameterNames().length; i++) {
parametersArray[i] = m.getParameterNames()[i].toCharArray();
parameters.add(
new Parameter(
ClassHelper.make(
Signature.getSignatureSimpleName(m.getParameterTypes()[i])),
m.getParameterNames()[i]));
}
final ClassNode classNode =
ClassHelper.make(m.getDeclaringType().getFullyQualifiedName());
proposal.setDeclarationSignature(
ProposalUtils.createTypeSignature(classNode));
proposal.setParameterNames(parametersArray);
if (m.getDeclaringType().getFullyQualifiedName().equals(f.getType())) {
proposal.setRelevance(100);
}
final MethodNode methodNode =
new MethodNode(
m.getElementName(),
m.getFlags(),
ClassHelper.make(
Signature.getSignatureSimpleName(m.getReturnType())),
parameters.toArray(new Parameter[parameters.size()]),
new ClassNode[0],
null);
final char[] methodSignature =
ProposalUtils.createMethodSignature(methodNode);
proposal.setSignature(methodSignature);
final GroovyJavaGuessingCompletionProposal groovyProposal =
GroovyJavaGuessingCompletionProposal.createProposal(
proposal,
(JavaContentAssistInvocationContext) context,
true,
"Groovy",
ProposalFormattingOptions.newFromOptions());
if (groovyProposal != null) {
list.add(groovyProposal);
}
}
}
}
}
}
} catch (final JavaModelException e) {
BonitaStudioLog.error(e);
}
}
}
return list;
}
} finally {
final CompletionContext coreContext =
((JavaContentAssistInvocationContext) context).getCoreContext();
if (extendContext && coreContext != null && coreContext.isExtended()) {
// must use reflection to set the fields
ReflectionUtils.setPrivateField(
InternalCompletionContext.class, "isExtended", coreContext, false);
}
}
return Collections.emptyList();
}