You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@groovy.apache.org by cc...@apache.org on 2017/12/14 21:56:52 UTC
[27/57] [abbrv] [partial] groovy git commit: Move Java source set
into `src/main/java`
http://git-wip-us.apache.org/repos/asf/groovy/blob/b25d0e55/src/main/java/org/codehaus/groovy/classgen/ExtendedVerifier.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/codehaus/groovy/classgen/ExtendedVerifier.java b/src/main/java/org/codehaus/groovy/classgen/ExtendedVerifier.java
new file mode 100644
index 0000000..5e13cd7
--- /dev/null
+++ b/src/main/java/org/codehaus/groovy/classgen/ExtendedVerifier.java
@@ -0,0 +1,342 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.codehaus.groovy.classgen;
+
+import org.codehaus.groovy.ast.ASTNode;
+import org.codehaus.groovy.ast.AnnotatedNode;
+import org.codehaus.groovy.ast.AnnotationNode;
+import org.codehaus.groovy.ast.ClassCodeVisitorSupport;
+import org.codehaus.groovy.ast.ClassHelper;
+import org.codehaus.groovy.ast.ClassNode;
+import org.codehaus.groovy.ast.ConstructorNode;
+import org.codehaus.groovy.ast.FieldNode;
+import org.codehaus.groovy.ast.GenericsType;
+import org.codehaus.groovy.ast.MethodNode;
+import org.codehaus.groovy.ast.PackageNode;
+import org.codehaus.groovy.ast.Parameter;
+import org.codehaus.groovy.ast.PropertyNode;
+import org.codehaus.groovy.ast.expr.AnnotationConstantExpression;
+import org.codehaus.groovy.ast.expr.ClassExpression;
+import org.codehaus.groovy.ast.expr.DeclarationExpression;
+import org.codehaus.groovy.ast.expr.Expression;
+import org.codehaus.groovy.ast.expr.ListExpression;
+import org.codehaus.groovy.ast.stmt.ReturnStatement;
+import org.codehaus.groovy.ast.stmt.Statement;
+import org.codehaus.groovy.ast.tools.ParameterUtils;
+import org.codehaus.groovy.control.AnnotationConstantsVisitor;
+import org.codehaus.groovy.control.CompilerConfiguration;
+import org.codehaus.groovy.control.ErrorCollector;
+import org.codehaus.groovy.control.SourceUnit;
+import org.codehaus.groovy.control.messages.SyntaxErrorMessage;
+import org.codehaus.groovy.syntax.SyntaxException;
+import org.objectweb.asm.Opcodes;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.codehaus.groovy.ast.tools.GenericsUtils.correctToGenericsSpec;
+import static org.codehaus.groovy.ast.tools.GenericsUtils.correctToGenericsSpecRecurse;
+import static org.codehaus.groovy.ast.tools.GenericsUtils.createGenericsSpec;
+
+/**
+ * A specialized Groovy AST visitor meant to perform additional verifications upon the
+ * current AST. Currently it does checks on annotated nodes and annotations itself.
+ * <p>
+ * Current limitations:
+ * - annotations on local variables are not supported
+ */
+public class ExtendedVerifier extends ClassCodeVisitorSupport {
+ public static final String JVM_ERROR_MESSAGE = "Please make sure you are running on a JVM >= 1.5";
+
+ private final SourceUnit source;
+ private ClassNode currentClass;
+
+ public ExtendedVerifier(SourceUnit sourceUnit) {
+ this.source = sourceUnit;
+ }
+
+ public void visitClass(ClassNode node) {
+ AnnotationConstantsVisitor acv = new AnnotationConstantsVisitor();
+ acv.visitClass(node, this.source);
+ this.currentClass = node;
+ if (node.isAnnotationDefinition()) {
+ visitAnnotations(node, AnnotationNode.ANNOTATION_TARGET);
+ } else {
+ visitAnnotations(node, AnnotationNode.TYPE_TARGET);
+ }
+ PackageNode packageNode = node.getPackage();
+ if (packageNode != null) {
+ visitAnnotations(packageNode, AnnotationNode.PACKAGE_TARGET);
+ }
+ node.visitContents(this);
+ }
+
+ public void visitField(FieldNode node) {
+ visitAnnotations(node, AnnotationNode.FIELD_TARGET);
+ }
+
+ @Override
+ public void visitDeclarationExpression(DeclarationExpression expression) {
+ visitAnnotations(expression, AnnotationNode.LOCAL_VARIABLE_TARGET);
+ }
+
+ public void visitConstructor(ConstructorNode node) {
+ visitConstructorOrMethod(node, AnnotationNode.CONSTRUCTOR_TARGET);
+ }
+
+ public void visitMethod(MethodNode node) {
+ visitConstructorOrMethod(node, AnnotationNode.METHOD_TARGET);
+ }
+
+ private void visitConstructorOrMethod(MethodNode node, int methodTarget) {
+ visitAnnotations(node, methodTarget);
+ for (int i = 0; i < node.getParameters().length; i++) {
+ Parameter parameter = node.getParameters()[i];
+ visitAnnotations(parameter, AnnotationNode.PARAMETER_TARGET);
+ }
+
+ if (this.currentClass.isAnnotationDefinition() && !node.isStaticConstructor()) {
+ ErrorCollector errorCollector = new ErrorCollector(this.source.getConfiguration());
+ AnnotationVisitor visitor = new AnnotationVisitor(this.source, errorCollector);
+ visitor.setReportClass(currentClass);
+ visitor.checkReturnType(node.getReturnType(), node);
+ if (node.getParameters().length > 0) {
+ addError("Annotation members may not have parameters.", node.getParameters()[0]);
+ }
+ if (node.getExceptions().length > 0) {
+ addError("Annotation members may not have a throws clause.", node.getExceptions()[0]);
+ }
+ ReturnStatement code = (ReturnStatement) node.getCode();
+ if (code != null) {
+ visitor.visitExpression(node.getName(), code.getExpression(), node.getReturnType());
+ visitor.checkCircularReference(currentClass, node.getReturnType(), code.getExpression());
+ }
+ this.source.getErrorCollector().addCollectorContents(errorCollector);
+ }
+ Statement code = node.getCode();
+ if (code != null) {
+ code.visit(this);
+ }
+
+ }
+
+ public void visitProperty(PropertyNode node) {
+ }
+
+ protected void visitAnnotations(AnnotatedNode node, int target) {
+ if (node.getAnnotations().isEmpty()) {
+ return;
+ }
+ this.currentClass.setAnnotated(true);
+ if (!isAnnotationCompatible()) {
+ addError("Annotations are not supported in the current runtime. " + JVM_ERROR_MESSAGE, node);
+ return;
+ }
+ Map<String, List<AnnotationNode>> runtimeAnnotations = new LinkedHashMap<String, List<AnnotationNode>>();
+ for (AnnotationNode unvisited : node.getAnnotations()) {
+ AnnotationNode visited = visitAnnotation(unvisited);
+ String name = visited.getClassNode().getName();
+ if (visited.hasRuntimeRetention()) {
+ List<AnnotationNode> seen = runtimeAnnotations.get(name);
+ if (seen == null) {
+ seen = new ArrayList<AnnotationNode>();
+ }
+ seen.add(visited);
+ runtimeAnnotations.put(name, seen);
+ }
+ boolean isTargetAnnotation = name.equals("java.lang.annotation.Target");
+
+ // Check if the annotation target is correct, unless it's the target annotating an annotation definition
+ // defining on which target elements the annotation applies
+ if (!isTargetAnnotation && !visited.isTargetAllowed(target)) {
+ addError("Annotation @" + name + " is not allowed on element "
+ + AnnotationNode.targetToName(target), visited);
+ }
+ visitDeprecation(node, visited);
+ visitOverride(node, visited);
+ }
+ checkForDuplicateAnnotations(node, runtimeAnnotations);
+ }
+
+ private void checkForDuplicateAnnotations(AnnotatedNode node, Map<String, List<AnnotationNode>> runtimeAnnotations) {
+ for (Map.Entry<String, List<AnnotationNode>> next : runtimeAnnotations.entrySet()) {
+ if (next.getValue().size() > 1) {
+ ClassNode repeatable = null;
+ AnnotationNode repeatee = next.getValue().get(0);
+ List<AnnotationNode> repeateeAnnotations = repeatee.getClassNode().getAnnotations();
+ for (AnnotationNode anno : repeateeAnnotations) {
+ ClassNode annoClassNode = anno.getClassNode();
+ if (annoClassNode.getName().equals("java.lang.annotation.Repeatable")) {
+ Expression value = anno.getMember("value");
+ if (value instanceof ClassExpression) {
+ ClassExpression ce = (ClassExpression) value;
+ if (ce.getType() != null && ce.getType().isAnnotationDefinition()) {
+ repeatable = ce.getType();
+ break;
+ }
+ }
+ }
+ }
+ if (repeatable != null) {
+ AnnotationNode collector = new AnnotationNode(repeatable);
+ collector.setRuntimeRetention(true); // checked earlier
+ List<Expression> annos = new ArrayList<Expression>();
+ for (AnnotationNode an : next.getValue()) {
+ annos.add(new AnnotationConstantExpression(an));
+ }
+ collector.addMember("value", new ListExpression(annos));
+ node.addAnnotation(collector);
+ node.getAnnotations().removeAll(next.getValue());
+ }
+ }
+ }
+ }
+
+ private static void visitDeprecation(AnnotatedNode node, AnnotationNode visited) {
+ if (visited.getClassNode().isResolved() && visited.getClassNode().getName().equals("java.lang.Deprecated")) {
+ if (node instanceof MethodNode) {
+ MethodNode mn = (MethodNode) node;
+ mn.setModifiers(mn.getModifiers() | Opcodes.ACC_DEPRECATED);
+ } else if (node instanceof FieldNode) {
+ FieldNode fn = (FieldNode) node;
+ fn.setModifiers(fn.getModifiers() | Opcodes.ACC_DEPRECATED);
+ } else if (node instanceof ClassNode) {
+ ClassNode cn = (ClassNode) node;
+ cn.setModifiers(cn.getModifiers() | Opcodes.ACC_DEPRECATED);
+ }
+ }
+ }
+
+ // TODO GROOVY-5011 handle case of @Override on a property
+ private void visitOverride(AnnotatedNode node, AnnotationNode visited) {
+ ClassNode annotationClassNode = visited.getClassNode();
+ if (annotationClassNode.isResolved() && annotationClassNode.getName().equals("java.lang.Override")) {
+ if (node instanceof MethodNode && !Boolean.TRUE.equals(node.getNodeMetaData(Verifier.DEFAULT_PARAMETER_GENERATED))) {
+ boolean override = false;
+ MethodNode origMethod = (MethodNode) node;
+ ClassNode cNode = origMethod.getDeclaringClass();
+ if (origMethod.hasDefaultValue()) {
+ List<MethodNode> variants = cNode.getDeclaredMethods(origMethod.getName());
+ for (MethodNode m : variants) {
+ if (m.getAnnotations().contains(visited) && isOverrideMethod(m)) {
+ override = true;
+ break;
+ }
+ }
+ } else {
+ override = isOverrideMethod(origMethod);
+ }
+
+ if (!override) {
+ addError("Method '" + origMethod.getName() + "' from class '" + cNode.getName() + "' does not override " +
+ "method from its superclass or interfaces but is annotated with @Override.", visited);
+ }
+ }
+ }
+ }
+
+ private static boolean isOverrideMethod(MethodNode method) {
+ ClassNode cNode = method.getDeclaringClass();
+ ClassNode next = cNode;
+ outer:
+ while (next != null) {
+ Map genericsSpec = createGenericsSpec(next);
+ MethodNode mn = correctToGenericsSpec(genericsSpec, method);
+ if (next != cNode) {
+ ClassNode correctedNext = correctToGenericsSpecRecurse(genericsSpec, next);
+ MethodNode found = getDeclaredMethodCorrected(genericsSpec, mn, correctedNext);
+ if (found != null) break;
+ }
+ List<ClassNode> ifaces = new ArrayList<ClassNode>();
+ ifaces.addAll(Arrays.asList(next.getInterfaces()));
+ Map updatedGenericsSpec = new HashMap(genericsSpec);
+ while (!ifaces.isEmpty()) {
+ ClassNode origInterface = ifaces.remove(0);
+ if (!origInterface.equals(ClassHelper.OBJECT_TYPE)) {
+ updatedGenericsSpec = createGenericsSpec(origInterface, updatedGenericsSpec);
+ ClassNode iNode = correctToGenericsSpecRecurse(updatedGenericsSpec, origInterface);
+ MethodNode found2 = getDeclaredMethodCorrected(updatedGenericsSpec, mn, iNode);
+ if (found2 != null) break outer;
+ ifaces.addAll(Arrays.asList(iNode.getInterfaces()));
+ }
+ }
+ ClassNode superClass = next.getUnresolvedSuperClass();
+ if (superClass != null) {
+ next = correctToGenericsSpecRecurse(updatedGenericsSpec, superClass);
+ } else {
+ next = null;
+ }
+ }
+ return next != null;
+ }
+
+ private static MethodNode getDeclaredMethodCorrected(Map genericsSpec, MethodNode mn, ClassNode correctedNext) {
+ for (MethodNode orig : correctedNext.getDeclaredMethods(mn.getName())) {
+ MethodNode method = correctToGenericsSpec(genericsSpec, orig);
+ if (ParameterUtils.parametersEqual(method.getParameters(), mn.getParameters())) {
+ return method;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Resolve metadata and details of the annotation.
+ *
+ * @param unvisited the node to visit
+ * @return the visited node
+ */
+ private AnnotationNode visitAnnotation(AnnotationNode unvisited) {
+ ErrorCollector errorCollector = new ErrorCollector(this.source.getConfiguration());
+ AnnotationVisitor visitor = new AnnotationVisitor(this.source, errorCollector);
+ AnnotationNode visited = visitor.visit(unvisited);
+ this.source.getErrorCollector().addCollectorContents(errorCollector);
+ return visited;
+ }
+
+ /**
+ * Check if the current runtime allows Annotation usage.
+ *
+ * @return true if running on a 1.5+ runtime
+ */
+ protected boolean isAnnotationCompatible() {
+ return CompilerConfiguration.isPostJDK5(this.source.getConfiguration().getTargetBytecode());
+ }
+
+ public void addError(String msg, ASTNode expr) {
+ this.source.getErrorCollector().addErrorAndContinue(
+ new SyntaxErrorMessage(
+ new SyntaxException(msg + '\n', expr.getLineNumber(), expr.getColumnNumber(), expr.getLastLineNumber(), expr.getLastColumnNumber()), this.source)
+ );
+ }
+
+ @Override
+ protected SourceUnit getSourceUnit() {
+ return source;
+ }
+
+ // TODO use it or lose it
+ public void visitGenericType(GenericsType genericsType) {
+
+ }
+}
http://git-wip-us.apache.org/repos/asf/groovy/blob/b25d0e55/src/main/java/org/codehaus/groovy/classgen/FinalVariableAnalyzer.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/codehaus/groovy/classgen/FinalVariableAnalyzer.java b/src/main/java/org/codehaus/groovy/classgen/FinalVariableAnalyzer.java
new file mode 100644
index 0000000..76c4e1f
--- /dev/null
+++ b/src/main/java/org/codehaus/groovy/classgen/FinalVariableAnalyzer.java
@@ -0,0 +1,363 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.codehaus.groovy.classgen;
+
+import org.codehaus.groovy.ast.ClassCodeVisitorSupport;
+import org.codehaus.groovy.ast.Parameter;
+import org.codehaus.groovy.ast.Variable;
+import org.codehaus.groovy.ast.expr.BinaryExpression;
+import org.codehaus.groovy.ast.expr.ClosureExpression;
+import org.codehaus.groovy.ast.expr.DeclarationExpression;
+import org.codehaus.groovy.ast.expr.EmptyExpression;
+import org.codehaus.groovy.ast.expr.Expression;
+import org.codehaus.groovy.ast.expr.PostfixExpression;
+import org.codehaus.groovy.ast.expr.PrefixExpression;
+import org.codehaus.groovy.ast.expr.TupleExpression;
+import org.codehaus.groovy.ast.expr.VariableExpression;
+import org.codehaus.groovy.ast.stmt.BlockStatement;
+import org.codehaus.groovy.ast.stmt.CatchStatement;
+import org.codehaus.groovy.ast.stmt.EmptyStatement;
+import org.codehaus.groovy.ast.stmt.IfStatement;
+import org.codehaus.groovy.ast.stmt.Statement;
+import org.codehaus.groovy.ast.stmt.TryCatchStatement;
+import org.codehaus.groovy.control.SourceUnit;
+import org.codehaus.groovy.transform.stc.StaticTypeCheckingSupport;
+
+import java.lang.reflect.Modifier;
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.Set;
+
+public class FinalVariableAnalyzer extends ClassCodeVisitorSupport {
+
+ private final SourceUnit sourceUnit;
+ private final VariableNotFinalCallback callback;
+
+ private Set<VariableExpression> declaredFinalVariables = null;
+ private boolean inAssignment = false;
+
+ private enum VariableState {
+ is_uninitialized(false),
+ is_final(true),
+ is_var(false);
+
+ private final boolean isFinal;
+
+ VariableState(final boolean isFinal) {
+ this.isFinal = isFinal;
+ }
+
+ public VariableState getNext() {
+ switch (this) {
+ case is_uninitialized:
+ return is_final;
+ default:
+ return is_var;
+ }
+ }
+
+ public boolean isFinal() {
+ return isFinal;
+ }
+ }
+
+ private final Deque<Map<Variable, VariableState>> assignmentTracker = new LinkedList<Map<Variable, VariableState>>();
+
+ public FinalVariableAnalyzer(final SourceUnit sourceUnit) {
+ this(sourceUnit, null);
+ }
+
+ public FinalVariableAnalyzer(final SourceUnit sourceUnit, final VariableNotFinalCallback callback) {
+ this.callback = callback;
+ this.sourceUnit = sourceUnit;
+ pushState();
+ }
+
+ private Map<Variable, VariableState> pushState() {
+ Map<Variable, VariableState> state = new StateMap();
+ assignmentTracker.add(state);
+ return state;
+ }
+
+ private static Variable getTarget(Variable v) {
+ if (v instanceof VariableExpression) {
+ Variable t = ((VariableExpression) v).getAccessedVariable();
+ if (t == v) return t;
+ return getTarget(t);
+ }
+ return v;
+ }
+
+ private Map<Variable, VariableState> popState() {
+ return assignmentTracker.removeLast();
+ }
+
+ private Map<Variable, VariableState> getState() {
+ return assignmentTracker.getLast();
+ }
+
+ @Override
+ protected SourceUnit getSourceUnit() {
+ return sourceUnit;
+ }
+
+ public boolean isEffectivelyFinal(Variable v) {
+ VariableState state = getState().get(v);
+ return (v instanceof Parameter && state == null)
+ || (state != null && state.isFinal());
+ }
+
+ @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;
+ }
+
+ @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);
+ } else if (leftExpression instanceof TupleExpression) {
+ TupleExpression te = (TupleExpression) leftExpression;
+ for (Expression next : te.getExpressions()) {
+ if (next instanceof Variable) {
+ recordAssignment((Variable) next, isDeclaration, false, false, next);
+ }
+ }
+ }
+ }
+ }
+
+ @Override
+ public void visitClosureExpression(final ClosureExpression expression) {
+ boolean old = inAssignment;
+ inAssignment = false;
+ super.visitClosureExpression(expression);
+ inAssignment = old;
+ }
+
+ @Override
+ public void visitPrefixExpression(final PrefixExpression expression) {
+ inAssignment = expression.getExpression() instanceof VariableExpression;
+ super.visitPrefixExpression(expression);
+ inAssignment = false;
+ checkPrePostfixOperation(expression.getExpression(), expression);
+ }
+
+ @Override
+ public void visitPostfixExpression(final PostfixExpression expression) {
+ inAssignment = expression.getExpression() instanceof VariableExpression;
+ super.visitPostfixExpression(expression);
+ inAssignment = false;
+ checkPrePostfixOperation(expression.getExpression(), expression);
+ }
+
+ private void checkPrePostfixOperation(final Expression variable, final Expression originalExpression) {
+ if (variable instanceof Variable) {
+ recordAssignment((Variable) variable, false, false, true, originalExpression);
+ if (variable instanceof VariableExpression) {
+ Variable accessed = ((VariableExpression) variable).getAccessedVariable();
+ if (accessed != variable) {
+ recordAssignment(accessed, false, false, true, originalExpression);
+ }
+ }
+ }
+ }
+
+ @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);
+ }
+ }
+ }
+
+ @Override
+ public void visitIfElse(final IfStatement ifElse) {
+ visitStatement(ifElse);
+ ifElse.getBooleanExpression().visit(this);
+ Map<Variable, VariableState> ifState = pushState();
+ ifElse.getIfBlock().visit(this);
+ popState();
+ Statement elseBlock = ifElse.getElseBlock();
+ Map<Variable, VariableState> elseState = pushState();
+ if (elseBlock instanceof EmptyStatement) {
+ // dispatching to EmptyStatement will not call back visitor,
+ // must call our visitEmptyStatement explicitly
+ visitEmptyStatement((EmptyStatement) elseBlock);
+ } else {
+ elseBlock.visit(this);
+ }
+ popState();
+
+ // merge if/else branches
+ Map<Variable, VariableState> curState = getState();
+ Set<Variable> allVars = new HashSet<Variable>();
+ allVars.addAll(curState.keySet());
+ allVars.addAll(ifState.keySet());
+ allVars.addAll(elseState.keySet());
+ for (Variable var : allVars) {
+ VariableState beforeValue = curState.get(var);
+ VariableState ifValue = ifState.get(var);
+ VariableState elseValue = elseState.get(var);
+ // merge if and else values
+ VariableState mergedIfElse;
+ mergedIfElse = ifValue != null && ifValue.isFinal
+ && elseValue != null && elseValue.isFinal ? VariableState.is_final : VariableState.is_var;
+ if (beforeValue == null) {
+ curState.put(var, mergedIfElse);
+ } else {
+ if (beforeValue == VariableState.is_uninitialized) {
+ curState.put(var, mergedIfElse);
+ } else if (ifValue != null || elseValue != null) {
+ curState.put(var, VariableState.is_var);
+ }
+ }
+ }
+ }
+
+ @Override
+ public void visitTryCatchFinally(final TryCatchStatement statement) {
+ visitStatement(statement);
+ Map<Variable, VariableState> beforeTryCatch = new HashMap<Variable, VariableState>(getState());
+ statement.getTryStatement().visit(this);
+ for (CatchStatement catchStatement : statement.getCatchStatements()) {
+ catchStatement.visit(this);
+ }
+ Statement finallyStatement = statement.getFinallyStatement();
+ // we need to recall which final variables are unassigned so cloning the current state
+ Map<Variable, VariableState> afterTryCatchState = new HashMap<Variable, VariableState>(getState());
+ if (finallyStatement instanceof EmptyStatement) {
+ // dispatching to EmptyStatement will not call back visitor,
+ // must call our visitEmptyStatement explicitly
+ visitEmptyStatement((EmptyStatement) finallyStatement);
+ } else {
+ finallyStatement.visit(this);
+ }
+ // and now we must reset to uninitialized state variables which were only initialized during try/catch
+ Map<Variable, VariableState> afterFinally = new HashMap<Variable, VariableState>(getState());
+ for (Map.Entry<Variable, VariableState> entry : afterFinally.entrySet()) {
+ Variable var = entry.getKey();
+ VariableState afterFinallyState = entry.getValue();
+ VariableState beforeTryCatchState = beforeTryCatch.get(var);
+ if (afterFinallyState == VariableState.is_final
+ && beforeTryCatchState != VariableState.is_final
+ && afterTryCatchState.get(var) != beforeTryCatchState) {
+ getState().put(var, beforeTryCatchState == null ? VariableState.is_uninitialized : beforeTryCatchState);
+ }
+ }
+ }
+
+ private void recordAssignment(
+ Variable var,
+ boolean isDeclaration,
+ boolean uninitialized,
+ boolean forceVariable,
+ Expression expression) {
+ if (var == null) {
+ return;
+ }
+ if (!isDeclaration && var.isClosureSharedVariable()) {
+ getState().put(var, VariableState.is_var);
+ }
+ VariableState variableState = getState().get(var);
+ if (variableState == null) {
+ variableState = uninitialized ? VariableState.is_uninitialized : VariableState.is_final;
+ if (getTarget(var) instanceof Parameter) {
+ variableState = VariableState.is_var;
+ }
+ } else {
+ variableState = variableState.getNext();
+ }
+ if (forceVariable) {
+ variableState = VariableState.is_var;
+ }
+ getState().put(var, variableState);
+ if (variableState == VariableState.is_var && callback != null) {
+ callback.variableNotFinal(var, expression);
+ }
+ }
+
+ public interface VariableNotFinalCallback {
+ /**
+ * Callback called whenever an assignment transforms an effectively final variable into a non final variable
+ * (aka, breaks the "final" modifier contract)
+ *
+ * @param var the variable detected as not final
+ * @param bexp the expression responsible for the contract to be broken
+ */
+ void variableNotFinal(Variable var, Expression bexp);
+
+ /**
+ * Callback used whenever a variable is declared as final, but can remain in an uninitialized state
+ *
+ * @param var the variable detected as potentially uninitialized
+ */
+ void variableNotAlwaysInitialized(VariableExpression var);
+ }
+
+ private static class StateMap extends HashMap<Variable, VariableState> {
+ @Override
+ public VariableState get(final Object key) {
+ return super.get(getTarget((Variable) key));
+ }
+
+ @Override
+ public VariableState put(final Variable key, final VariableState value) {
+ return super.put(getTarget(key), value);
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/groovy/blob/b25d0e55/src/main/java/org/codehaus/groovy/classgen/GeneratorContext.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/codehaus/groovy/classgen/GeneratorContext.java b/src/main/java/org/codehaus/groovy/classgen/GeneratorContext.java
new file mode 100644
index 0000000..8b8a510
--- /dev/null
+++ b/src/main/java/org/codehaus/groovy/classgen/GeneratorContext.java
@@ -0,0 +1,113 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.codehaus.groovy.classgen;
+
+import org.codehaus.groovy.GroovyBugError;
+import org.codehaus.groovy.ast.ClassHelper;
+import org.codehaus.groovy.ast.ClassNode;
+import org.codehaus.groovy.ast.CompileUnit;
+import org.codehaus.groovy.ast.MethodNode;
+
+
+/**
+ * A context shared across generations of a class and its inner classes
+ *
+ * @author <a href="mailto:james@coredevelopers.net">James Strachan</a>
+ */
+public class GeneratorContext {
+
+ private int innerClassIdx = 1;
+ private int closureClassIdx = 1;
+ private final CompileUnit compileUnit;
+
+ public GeneratorContext(CompileUnit compileUnit) {
+ this.compileUnit = compileUnit;
+ }
+
+ public GeneratorContext(CompileUnit compileUnit, int innerClassOffset) {
+ this.compileUnit = compileUnit;
+ this.innerClassIdx = innerClassOffset;
+ }
+
+ public int getNextInnerClassIdx() {
+ return innerClassIdx++;
+ }
+
+ public CompileUnit getCompileUnit() {
+ return compileUnit;
+ }
+
+ public String getNextClosureInnerName(ClassNode owner, ClassNode enclosingClass, MethodNode enclosingMethod) {
+ String methodName = "";
+ if (enclosingMethod != null) {
+ methodName = enclosingMethod.getName();
+
+ if (enclosingClass.isDerivedFrom(ClassHelper.CLOSURE_TYPE)) {
+ methodName = "";
+ } else {
+ methodName = "_"+encodeAsValidClassName(methodName);
+ }
+ }
+ return methodName + "_closure" + closureClassIdx++;
+ }
+
+
+ private static final int MIN_ENCODING = ' ';
+ private static final int MAX_ENCODING = ']';
+ private static final boolean[] CHARACTERS_TO_ENCODE = new boolean[MAX_ENCODING-MIN_ENCODING+1];
+ static {
+ CHARACTERS_TO_ENCODE[' '-MIN_ENCODING] = true;
+ CHARACTERS_TO_ENCODE['!'-MIN_ENCODING] = true;
+ CHARACTERS_TO_ENCODE['/'-MIN_ENCODING] = true;
+ CHARACTERS_TO_ENCODE['.'-MIN_ENCODING] = true;
+ CHARACTERS_TO_ENCODE[';'-MIN_ENCODING] = true;
+ CHARACTERS_TO_ENCODE['$'-MIN_ENCODING] = true;
+ CHARACTERS_TO_ENCODE['<'-MIN_ENCODING] = true;
+ CHARACTERS_TO_ENCODE['>'-MIN_ENCODING] = true;
+ CHARACTERS_TO_ENCODE['['-MIN_ENCODING] = true;
+ CHARACTERS_TO_ENCODE[']'-MIN_ENCODING] = true;
+ CHARACTERS_TO_ENCODE[':'-MIN_ENCODING] = true;
+ CHARACTERS_TO_ENCODE['\\'-MIN_ENCODING] = true;
+ }
+
+ public static String encodeAsValidClassName(String name) {
+ final int l = name.length();
+ StringBuilder b = null;
+ int lastEscape = -1;
+ for(int i = 0; i < l; ++i) {
+ final int encodeIndex = name.charAt(i) - MIN_ENCODING;
+ if (encodeIndex >= 0 && encodeIndex < CHARACTERS_TO_ENCODE.length) {
+ if (CHARACTERS_TO_ENCODE[encodeIndex]) {
+ if(b == null) {
+ b = new StringBuilder(name.length() + 3);
+ b.append(name, 0, i);
+ } else {
+ b.append(name, lastEscape + 1, i);
+ }
+ b.append('_');
+ lastEscape = i;
+ }
+ }
+ }
+ if(b == null) return name.toString();
+ if (lastEscape == -1) throw new GroovyBugError("unexpected escape char control flow in "+name);
+ b.append(name, lastEscape + 1, l);
+ return b.toString();
+ }
+}
http://git-wip-us.apache.org/repos/asf/groovy/blob/b25d0e55/src/main/java/org/codehaus/groovy/classgen/InnerClassCompletionVisitor.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/codehaus/groovy/classgen/InnerClassCompletionVisitor.java b/src/main/java/org/codehaus/groovy/classgen/InnerClassCompletionVisitor.java
new file mode 100644
index 0000000..a8d84c8
--- /dev/null
+++ b/src/main/java/org/codehaus/groovy/classgen/InnerClassCompletionVisitor.java
@@ -0,0 +1,454 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.codehaus.groovy.classgen;
+
+import org.codehaus.groovy.ast.ClassHelper;
+import org.codehaus.groovy.ast.ClassNode;
+import org.codehaus.groovy.ast.ConstructorNode;
+import org.codehaus.groovy.ast.FieldNode;
+import org.codehaus.groovy.ast.InnerClassNode;
+import org.codehaus.groovy.ast.MethodNode;
+import org.codehaus.groovy.ast.Parameter;
+import org.codehaus.groovy.ast.expr.ClassExpression;
+import org.codehaus.groovy.ast.expr.ConstructorCallExpression;
+import org.codehaus.groovy.ast.expr.Expression;
+import org.codehaus.groovy.ast.expr.TupleExpression;
+import org.codehaus.groovy.ast.expr.VariableExpression;
+import org.codehaus.groovy.ast.stmt.BlockStatement;
+import org.codehaus.groovy.ast.stmt.ExpressionStatement;
+import org.codehaus.groovy.ast.stmt.Statement;
+import org.codehaus.groovy.classgen.asm.BytecodeHelper;
+import org.codehaus.groovy.control.CompilationUnit;
+import org.codehaus.groovy.control.SourceUnit;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+import java.util.List;
+
+import static org.codehaus.groovy.ast.ClassHelper.CLOSURE_TYPE;
+
+public class InnerClassCompletionVisitor extends InnerClassVisitorHelper implements Opcodes {
+
+ private final SourceUnit sourceUnit;
+ private ClassNode classNode;
+ private FieldNode thisField = null;
+
+ private static final String
+ CLOSURE_INTERNAL_NAME = BytecodeHelper.getClassInternalName(CLOSURE_TYPE),
+ CLOSURE_DESCRIPTOR = BytecodeHelper.getTypeDescription(CLOSURE_TYPE);
+
+ public InnerClassCompletionVisitor(CompilationUnit cu, SourceUnit su) {
+ sourceUnit = su;
+ }
+
+ @Override
+ protected SourceUnit getSourceUnit() {
+ return sourceUnit;
+ }
+
+ @Override
+ public void visitClass(ClassNode node) {
+ this.classNode = node;
+ thisField = null;
+ InnerClassNode innerClass = null;
+ if (!node.isEnum() && !node.isInterface() && node instanceof InnerClassNode) {
+ innerClass = (InnerClassNode) node;
+ thisField = innerClass.getField("this$0");
+ if (innerClass.getVariableScope() == null && innerClass.getDeclaredConstructors().isEmpty()) {
+ // add dummy constructor
+ innerClass.addConstructor(ACC_PUBLIC, Parameter.EMPTY_ARRAY, null, null);
+ }
+ }
+ if (node.isEnum() || node.isInterface()) return;
+ // use Iterator.hasNext() to check for available inner classes
+ if (node.getInnerClasses().hasNext()) addDispatcherMethods(node);
+ if (innerClass == null) return;
+ super.visitClass(node);
+ addDefaultMethods(innerClass);
+ }
+
+ @Override
+ public void visitConstructor(ConstructorNode node) {
+ addThisReference(node);
+ super.visitConstructor(node);
+ }
+
+ private static String getTypeDescriptor(ClassNode node, boolean isStatic) {
+ return BytecodeHelper.getTypeDescription(getClassNode(node, isStatic));
+ }
+
+ private static String getInternalName(ClassNode node, boolean isStatic) {
+ return BytecodeHelper.getClassInternalName(getClassNode(node, isStatic));
+ }
+
+ private static void addDispatcherMethods(ClassNode classNode) {
+ final int objectDistance = getObjectDistance(classNode);
+
+ // since we added an anonymous inner class we should also
+ // add the dispatcher methods
+
+ // add method dispatcher
+ Parameter[] parameters = new Parameter[]{
+ new Parameter(ClassHelper.STRING_TYPE, "name"),
+ new Parameter(ClassHelper.OBJECT_TYPE, "args")
+ };
+ MethodNode method = classNode.addSyntheticMethod(
+ "this$dist$invoke$" + objectDistance,
+ ACC_PUBLIC + ACC_SYNTHETIC,
+ ClassHelper.OBJECT_TYPE,
+ parameters,
+ ClassNode.EMPTY_ARRAY,
+ null
+ );
+
+ BlockStatement block = new BlockStatement();
+ setMethodDispatcherCode(block, VariableExpression.THIS_EXPRESSION, parameters);
+ method.setCode(block);
+
+ // add property setter
+ parameters = new Parameter[]{
+ new Parameter(ClassHelper.STRING_TYPE, "name"),
+ new Parameter(ClassHelper.OBJECT_TYPE, "value")
+ };
+ method = classNode.addSyntheticMethod(
+ "this$dist$set$" + objectDistance,
+ ACC_PUBLIC + ACC_SYNTHETIC,
+ ClassHelper.VOID_TYPE,
+ parameters,
+ ClassNode.EMPTY_ARRAY,
+ null
+ );
+
+ block = new BlockStatement();
+ setPropertySetterDispatcher(block, VariableExpression.THIS_EXPRESSION, parameters);
+ method.setCode(block);
+
+ // add property getter
+ parameters = new Parameter[]{
+ new Parameter(ClassHelper.STRING_TYPE, "name")
+ };
+ method = classNode.addSyntheticMethod(
+ "this$dist$get$" + objectDistance,
+ ACC_PUBLIC + ACC_SYNTHETIC,
+ ClassHelper.OBJECT_TYPE,
+ parameters,
+ ClassNode.EMPTY_ARRAY,
+ null
+ );
+
+ block = new BlockStatement();
+ setPropertyGetterDispatcher(block, VariableExpression.THIS_EXPRESSION, parameters);
+ method.setCode(block);
+ }
+
+ private void getThis(MethodVisitor mv, String classInternalName, String outerClassDescriptor, String innerClassInternalName) {
+ mv.visitVarInsn(ALOAD, 0);
+ if (CLOSURE_TYPE.equals(thisField.getType())) {
+ mv.visitFieldInsn(GETFIELD, classInternalName, "this$0", CLOSURE_DESCRIPTOR);
+ mv.visitMethodInsn(INVOKEVIRTUAL, CLOSURE_INTERNAL_NAME, "getThisObject", "()Ljava/lang/Object;", false);
+ mv.visitTypeInsn(CHECKCAST, innerClassInternalName);
+ } else {
+ mv.visitFieldInsn(GETFIELD, classInternalName, "this$0", outerClassDescriptor);
+ }
+ }
+
+ private void addDefaultMethods(InnerClassNode node) {
+ final boolean isStatic = isStatic(node);
+
+ ClassNode outerClass = node.getOuterClass();
+ final String classInternalName = org.codehaus.groovy.classgen.asm.BytecodeHelper.getClassInternalName(node);
+ final String outerClassInternalName = getInternalName(outerClass, isStatic);
+ final String outerClassDescriptor = getTypeDescriptor(outerClass, isStatic);
+ final int objectDistance = getObjectDistance(outerClass);
+
+ // add missing method dispatcher
+ Parameter[] parameters = new Parameter[]{
+ new Parameter(ClassHelper.STRING_TYPE, "name"),
+ new Parameter(ClassHelper.OBJECT_TYPE, "args")
+ };
+
+ String methodName = "methodMissing";
+ if (isStatic)
+ addCompilationErrorOnCustomMethodNode(node, methodName, parameters);
+
+ MethodNode method = node.addSyntheticMethod(
+ methodName,
+ Opcodes.ACC_PUBLIC,
+ ClassHelper.OBJECT_TYPE,
+ parameters,
+ ClassNode.EMPTY_ARRAY,
+ null
+ );
+
+ BlockStatement block = new BlockStatement();
+ if (isStatic) {
+ setMethodDispatcherCode(block, new ClassExpression(outerClass), parameters);
+ } else {
+ block.addStatement(
+ new BytecodeSequence(new BytecodeInstruction() {
+ public void visit(MethodVisitor mv) {
+ getThis(mv,classInternalName,outerClassDescriptor,outerClassInternalName);
+ mv.visitVarInsn(ALOAD, 1);
+ mv.visitVarInsn(ALOAD, 2);
+ mv.visitMethodInsn(INVOKEVIRTUAL, outerClassInternalName, "this$dist$invoke$" + objectDistance, "(Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object;", false);
+ mv.visitInsn(ARETURN);
+ }
+ })
+ );
+ }
+ method.setCode(block);
+
+ // add static missing method dispatcher
+ methodName = "$static_methodMissing";
+ if (isStatic)
+ addCompilationErrorOnCustomMethodNode(node, methodName, parameters);
+
+ method = node.addSyntheticMethod(
+ methodName,
+ Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC,
+ ClassHelper.OBJECT_TYPE,
+ parameters,
+ ClassNode.EMPTY_ARRAY,
+ null
+ );
+
+ block = new BlockStatement();
+ setMethodDispatcherCode(block, new ClassExpression(outerClass), parameters);
+ method.setCode(block);
+
+ // add property setter dispatcher
+ parameters = new Parameter[]{
+ new Parameter(ClassHelper.STRING_TYPE, "name"),
+ new Parameter(ClassHelper.OBJECT_TYPE, "val")
+ };
+
+ methodName = "propertyMissing";
+ if (isStatic)
+ addCompilationErrorOnCustomMethodNode(node, methodName, parameters);
+
+ method = node.addSyntheticMethod(
+ methodName,
+ Opcodes.ACC_PUBLIC,
+ ClassHelper.VOID_TYPE,
+ parameters,
+ ClassNode.EMPTY_ARRAY,
+ null
+ );
+
+ block = new BlockStatement();
+ if (isStatic) {
+ setPropertySetterDispatcher(block, new ClassExpression(outerClass), parameters);
+ } else {
+ block.addStatement(
+ new BytecodeSequence(new BytecodeInstruction() {
+ public void visit(MethodVisitor mv) {
+ getThis(mv,classInternalName,outerClassDescriptor,outerClassInternalName);
+ mv.visitVarInsn(ALOAD, 1);
+ mv.visitVarInsn(ALOAD, 2);
+ mv.visitMethodInsn(INVOKEVIRTUAL, outerClassInternalName, "this$dist$set$" + objectDistance, "(Ljava/lang/String;Ljava/lang/Object;)V", false);
+ mv.visitInsn(RETURN);
+ }
+ })
+ );
+ }
+ method.setCode(block);
+
+ // add static property missing setter dispatcher
+ methodName = "$static_propertyMissing";
+ if (isStatic)
+ addCompilationErrorOnCustomMethodNode(node, methodName, parameters);
+
+ method = node.addSyntheticMethod(
+ methodName,
+ Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC,
+ ClassHelper.VOID_TYPE,
+ parameters,
+ ClassNode.EMPTY_ARRAY,
+ null
+ );
+
+ block = new BlockStatement();
+ setPropertySetterDispatcher(block, new ClassExpression(outerClass), parameters);
+ method.setCode(block);
+
+ // add property getter dispatcher
+ parameters = new Parameter[]{
+ new Parameter(ClassHelper.STRING_TYPE, "name")
+ };
+
+ methodName = "propertyMissing";
+ if (isStatic)
+ addCompilationErrorOnCustomMethodNode(node, methodName, parameters);
+
+ method = node.addSyntheticMethod(
+ methodName,
+ Opcodes.ACC_PUBLIC,
+ ClassHelper.OBJECT_TYPE,
+ parameters,
+ ClassNode.EMPTY_ARRAY,
+ null
+ );
+
+ block = new BlockStatement();
+ if (isStatic) {
+ setPropertyGetterDispatcher(block, new ClassExpression(outerClass), parameters);
+ } else {
+ block.addStatement(
+ new BytecodeSequence(new BytecodeInstruction() {
+ public void visit(MethodVisitor mv) {
+ getThis(mv,classInternalName,outerClassDescriptor,outerClassInternalName);
+ mv.visitVarInsn(ALOAD, 1);
+ mv.visitMethodInsn(INVOKEVIRTUAL, outerClassInternalName, "this$dist$get$" + objectDistance, "(Ljava/lang/String;)Ljava/lang/Object;", false);
+ mv.visitInsn(ARETURN);
+ }
+ })
+ );
+ }
+ method.setCode(block);
+
+ // add static property missing getter dispatcher
+ methodName = "$static_propertyMissing";
+ if (isStatic)
+ addCompilationErrorOnCustomMethodNode(node, methodName, parameters);
+
+ method = node.addSyntheticMethod(
+ methodName,
+ Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC,
+ ClassHelper.OBJECT_TYPE,
+ parameters,
+ ClassNode.EMPTY_ARRAY,
+ null
+ );
+
+ block = new BlockStatement();
+ setPropertyGetterDispatcher(block, new ClassExpression(outerClass), parameters);
+ method.setCode(block);
+ }
+
+ /**
+ * Adds a compilation error if a {@link MethodNode} with the given <tt>methodName</tt> and
+ * <tt>parameters</tt> exists in the {@link InnerClassNode}.
+ */
+ private void addCompilationErrorOnCustomMethodNode(InnerClassNode node, String methodName, Parameter[] parameters) {
+ MethodNode existingMethodNode = node.getMethod(methodName, parameters);
+ // if there is a user-defined methodNode, add compiler error msg and continue
+ if (existingMethodNode != null && !existingMethodNode.isSynthetic()) {
+ addError("\"" +methodName + "\" implementations are not supported on static inner classes as " +
+ "a synthetic version of \"" + methodName + "\" is added during compilation for the purpose " +
+ "of outer class delegation.",
+ existingMethodNode);
+ }
+ }
+
+ private void addThisReference(ConstructorNode node) {
+ if (!shouldHandleImplicitThisForInnerClass(classNode)) return;
+ Statement code = node.getCode();
+
+ // add "this$0" field init
+
+ //add this parameter to node
+ Parameter[] params = node.getParameters();
+ Parameter[] newParams = new Parameter[params.length + 1];
+ System.arraycopy(params, 0, newParams, 1, params.length);
+ String name = getUniqueName(params, node);
+
+ Parameter thisPara = new Parameter(classNode.getOuterClass().getPlainNodeReference(), name);
+ newParams[0] = thisPara;
+ node.setParameters(newParams);
+
+ BlockStatement block = null;
+ if (code == null) {
+ block = new BlockStatement();
+ } else if (!(code instanceof BlockStatement)) {
+ block = new BlockStatement();
+ block.addStatement(code);
+ } else {
+ block = (BlockStatement) code;
+ }
+ BlockStatement newCode = new BlockStatement();
+ addFieldInit(thisPara, thisField, newCode);
+ ConstructorCallExpression cce = getFirstIfSpecialConstructorCall(block);
+ if (cce == null) {
+ cce = new ConstructorCallExpression(ClassNode.SUPER, new TupleExpression());
+ block.getStatements().add(0, new ExpressionStatement(cce));
+ }
+ if (shouldImplicitlyPassThisPara(cce)) {
+ // add thisPara to this(...)
+ TupleExpression args = (TupleExpression) cce.getArguments();
+ List<Expression> expressions = args.getExpressions();
+ VariableExpression ve = new VariableExpression(thisPara.getName());
+ ve.setAccessedVariable(thisPara);
+ expressions.add(0, ve);
+ }
+ if (cce.isSuperCall()) {
+ // we have a call to super here, so we need to add
+ // our code after that
+ block.getStatements().add(1, newCode);
+ }
+ node.setCode(block);
+ }
+
+ private boolean shouldImplicitlyPassThisPara(ConstructorCallExpression cce) {
+ boolean pass = false;
+ ClassNode superCN = classNode.getSuperClass();
+ if (cce.isThisCall()) {
+ pass = true;
+ } else if (cce.isSuperCall()) {
+ // if the super class is another non-static inner class in the same outer class hierarchy, implicit this
+ // needs to be passed
+ if (!superCN.isEnum() && !superCN.isInterface() && superCN instanceof InnerClassNode) {
+ InnerClassNode superInnerCN = (InnerClassNode) superCN;
+ if (!isStatic(superInnerCN) && classNode.getOuterClass().isDerivedFrom(superCN.getOuterClass())) {
+ pass = true;
+ }
+ }
+ }
+ return pass;
+ }
+
+ private String getUniqueName(Parameter[] params, ConstructorNode node) {
+ String namePrefix = "$p";
+ outer:
+ for (int i = 0; i < 100; i++) {
+ namePrefix = namePrefix + "$";
+ for (Parameter p : params) {
+ if (p.getName().equals(namePrefix)) continue outer;
+ }
+ return namePrefix;
+ }
+ addError("unable to find a unique prefix name for synthetic this reference in inner class constructor", node);
+ return namePrefix;
+ }
+
+ private static ConstructorCallExpression getFirstIfSpecialConstructorCall(BlockStatement code) {
+ if (code == null) return null;
+
+ final List<Statement> statementList = code.getStatements();
+ if (statementList.isEmpty()) return null;
+
+ final Statement statement = statementList.get(0);
+ if (!(statement instanceof ExpressionStatement)) return null;
+
+ Expression expression = ((ExpressionStatement) statement).getExpression();
+ if (!(expression instanceof ConstructorCallExpression)) return null;
+ ConstructorCallExpression cce = (ConstructorCallExpression) expression;
+ if (cce.isSpecialCall()) return cce;
+ return null;
+ }
+}
http://git-wip-us.apache.org/repos/asf/groovy/blob/b25d0e55/src/main/java/org/codehaus/groovy/classgen/InnerClassVisitor.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/codehaus/groovy/classgen/InnerClassVisitor.java b/src/main/java/org/codehaus/groovy/classgen/InnerClassVisitor.java
new file mode 100644
index 0000000..87815a8
--- /dev/null
+++ b/src/main/java/org/codehaus/groovy/classgen/InnerClassVisitor.java
@@ -0,0 +1,288 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.codehaus.groovy.classgen;
+
+import org.codehaus.groovy.ast.ClassHelper;
+import org.codehaus.groovy.ast.ClassNode;
+import org.codehaus.groovy.ast.FieldNode;
+import org.codehaus.groovy.ast.InnerClassNode;
+import org.codehaus.groovy.ast.MethodNode;
+import org.codehaus.groovy.ast.Parameter;
+import org.codehaus.groovy.ast.PropertyNode;
+import org.codehaus.groovy.ast.VariableScope;
+import org.codehaus.groovy.ast.expr.ClosureExpression;
+import org.codehaus.groovy.ast.expr.ConstructorCallExpression;
+import org.codehaus.groovy.ast.expr.Expression;
+import org.codehaus.groovy.ast.expr.PropertyExpression;
+import org.codehaus.groovy.ast.expr.TupleExpression;
+import org.codehaus.groovy.ast.expr.VariableExpression;
+import org.codehaus.groovy.ast.stmt.BlockStatement;
+import org.codehaus.groovy.ast.stmt.ExpressionStatement;
+import org.codehaus.groovy.control.CompilationUnit;
+import org.codehaus.groovy.control.SourceUnit;
+import org.objectweb.asm.Opcodes;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public class InnerClassVisitor extends InnerClassVisitorHelper implements Opcodes {
+
+ private final SourceUnit sourceUnit;
+ private ClassNode classNode;
+ private static final int PUBLIC_SYNTHETIC = Opcodes.ACC_PUBLIC + Opcodes.ACC_SYNTHETIC;
+ private FieldNode thisField = null;
+ private MethodNode currentMethod;
+ private FieldNode currentField;
+ private boolean processingObjInitStatements = false;
+ private boolean inClosure = false;
+
+ public InnerClassVisitor(CompilationUnit cu, SourceUnit su) {
+ sourceUnit = su;
+ }
+
+ @Override
+ protected SourceUnit getSourceUnit() {
+ return sourceUnit;
+ }
+
+ @Override
+ public void visitClass(ClassNode node) {
+ this.classNode = node;
+ thisField = null;
+ InnerClassNode innerClass = null;
+ if (!node.isEnum() && !node.isInterface() && node instanceof InnerClassNode) {
+ innerClass = (InnerClassNode) node;
+ if (!isStatic(innerClass) && innerClass.getVariableScope() == null) {
+ thisField = innerClass.addField("this$0", PUBLIC_SYNTHETIC, node.getOuterClass().getPlainNodeReference(), null);
+ }
+ }
+
+ super.visitClass(node);
+
+ if (node.isEnum() || node.isInterface()) return;
+ if (innerClass == null) return;
+
+ if (node.getSuperClass().isInterface()) {
+ node.addInterface(node.getUnresolvedSuperClass());
+ node.setUnresolvedSuperClass(ClassHelper.OBJECT_TYPE);
+ }
+ }
+
+ @Override
+ public void visitClosureExpression(ClosureExpression expression) {
+ boolean inClosureOld = inClosure;
+ inClosure = true;
+ super.visitClosureExpression(expression);
+ inClosure = inClosureOld;
+ }
+
+ @Override
+ protected void visitObjectInitializerStatements(ClassNode node) {
+ processingObjInitStatements = true;
+ super.visitObjectInitializerStatements(node);
+ processingObjInitStatements = false;
+ }
+
+ @Override
+ protected void visitConstructorOrMethod(MethodNode node, boolean isConstructor) {
+ this.currentMethod = node;
+ visitAnnotations(node);
+ visitClassCodeContainer(node.getCode());
+ // GROOVY-5681: initial expressions should be visited too!
+ for (Parameter param : node.getParameters()) {
+ if (param.hasInitialExpression()) {
+ param.getInitialExpression().visit(this);
+ }
+ visitAnnotations(param);
+ }
+ this.currentMethod = null;
+ }
+
+ @Override
+ public void visitField(FieldNode node) {
+ this.currentField = node;
+ super.visitField(node);
+ this.currentField = null;
+ }
+
+ @Override
+ public void visitProperty(PropertyNode node) {
+ final FieldNode field = node.getField();
+ final Expression init = field.getInitialExpression();
+ field.setInitialValueExpression(null);
+ super.visitProperty(node);
+ field.setInitialValueExpression(init);
+ }
+
+ @Override
+ public void visitConstructorCallExpression(ConstructorCallExpression call) {
+ super.visitConstructorCallExpression(call);
+ if (!call.isUsingAnonymousInnerClass()) {
+ passThisReference(call);
+ return;
+ }
+
+ InnerClassNode innerClass = (InnerClassNode) call.getType();
+ ClassNode outerClass = innerClass.getOuterClass();
+ ClassNode superClass = innerClass.getSuperClass();
+ if (superClass instanceof InnerClassNode
+ && !superClass.isInterface()
+ && !(superClass.isStaticClass()||((superClass.getModifiers()&ACC_STATIC)==ACC_STATIC))) {
+ insertThis0ToSuperCall(call, innerClass);
+ }
+ if (!innerClass.getDeclaredConstructors().isEmpty()) return;
+ if ((innerClass.getModifiers() & ACC_STATIC) != 0) return;
+
+ VariableScope scope = innerClass.getVariableScope();
+ if (scope == null) return;
+
+ // expressions = constructor call arguments
+ List<Expression> expressions = ((TupleExpression) call.getArguments()).getExpressions();
+ // block = init code for the constructor we produce
+ BlockStatement block = new BlockStatement();
+ // parameters = parameters of the constructor
+ final int additionalParamCount = 1 + scope.getReferencedLocalVariablesCount();
+ List<Parameter> parameters = new ArrayList<Parameter>(expressions.size() + additionalParamCount);
+ // superCallArguments = arguments for the super call == the constructor call arguments
+ List<Expression> superCallArguments = new ArrayList<Expression>(expressions.size());
+
+ // first we add a super() call for all expressions given in the
+ // constructor call expression
+ int pCount = additionalParamCount;
+ for (Expression expr : expressions) {
+ pCount++;
+ // add one parameter for each expression in the
+ // constructor call
+ Parameter param = new Parameter(ClassHelper.OBJECT_TYPE, "p" + pCount);
+ parameters.add(param);
+ // add to super call
+ superCallArguments.add(new VariableExpression(param));
+ }
+
+ // add the super call
+ ConstructorCallExpression cce = new ConstructorCallExpression(
+ ClassNode.SUPER,
+ new TupleExpression(superCallArguments)
+ );
+
+ block.addStatement(new ExpressionStatement(cce));
+
+ // we need to add "this" to access unknown methods/properties
+ // this is saved in a field named this$0
+ pCount = 0;
+ expressions.add(pCount, VariableExpression.THIS_EXPRESSION);
+ boolean isStatic = isStaticThis(innerClass,scope);
+ ClassNode outerClassType = getClassNode(outerClass, isStatic);
+ if (!isStatic && inClosure) outerClassType = ClassHelper.CLOSURE_TYPE;
+ outerClassType = outerClassType.getPlainNodeReference();
+ Parameter thisParameter = new Parameter(outerClassType, "p" + pCount);
+ parameters.add(pCount, thisParameter);
+
+ thisField = innerClass.addField("this$0", PUBLIC_SYNTHETIC, outerClassType, null);
+ addFieldInit(thisParameter, thisField, block);
+
+ // for each shared variable we add a reference and save it as field
+ for (Iterator it = scope.getReferencedLocalVariablesIterator(); it.hasNext();) {
+ pCount++;
+ org.codehaus.groovy.ast.Variable var = (org.codehaus.groovy.ast.Variable) it.next();
+ VariableExpression ve = new VariableExpression(var);
+ ve.setClosureSharedVariable(true);
+ ve.setUseReferenceDirectly(true);
+ expressions.add(pCount, ve);
+
+ ClassNode rawReferenceType = ClassHelper.REFERENCE_TYPE.getPlainNodeReference();
+ Parameter p = new Parameter(rawReferenceType, "p" + pCount);
+ parameters.add(pCount, p);
+ p.setOriginType(var.getOriginType());
+ final VariableExpression initial = new VariableExpression(p);
+ initial.setSynthetic(true);
+ initial.setUseReferenceDirectly(true);
+ final FieldNode pField = innerClass.addFieldFirst(ve.getName(), PUBLIC_SYNTHETIC,rawReferenceType, initial);
+ pField.setHolder(true);
+ pField.setOriginType(ClassHelper.getWrapper(var.getOriginType()));
+ }
+
+ innerClass.addConstructor(ACC_SYNTHETIC, parameters.toArray(new Parameter[parameters.size()]), ClassNode.EMPTY_ARRAY, block);
+ }
+
+ private boolean isStaticThis(InnerClassNode innerClass, VariableScope scope) {
+ if (inClosure) return false;
+ boolean ret = innerClass.isStaticClass();
+ if ( innerClass.getEnclosingMethod()!=null) {
+ ret = ret || innerClass.getEnclosingMethod().isStatic();
+ } else if (currentField!=null) {
+ ret = ret || currentField.isStatic();
+ } else if (currentMethod!=null && "<clinit>".equals(currentMethod.getName())) {
+ ret = true;
+ }
+ return ret;
+ }
+
+ // this is the counterpart of addThisReference(). To non-static inner classes, outer this should be
+ // passed as the first argument implicitly.
+ private void passThisReference(ConstructorCallExpression call) {
+ ClassNode cn = call.getType().redirect();
+ if (!shouldHandleImplicitThisForInnerClass(cn)) return;
+
+ boolean isInStaticContext = true;
+ if (currentMethod != null)
+ isInStaticContext = currentMethod.getVariableScope().isInStaticContext();
+ else if (currentField != null)
+ isInStaticContext = currentField.isStatic();
+ else if (processingObjInitStatements)
+ isInStaticContext = false;
+
+ // if constructor call is not in static context, return
+ if (isInStaticContext) {
+ // constructor call is in static context and the inner class is non-static - 1st arg is supposed to be
+ // passed as enclosing "this" instance
+ //
+ Expression args = call.getArguments();
+ if (args instanceof TupleExpression && ((TupleExpression) args).getExpressions().isEmpty()) {
+ addError("No enclosing instance passed in constructor call of a non-static inner class", call);
+ }
+ return;
+ }
+ insertThis0ToSuperCall(call, cn);
+
+ }
+
+ private void insertThis0ToSuperCall(final ConstructorCallExpression call, final ClassNode cn) {
+ // calculate outer class which we need for this$0
+ ClassNode parent = classNode;
+ int level = 0;
+ for (; parent != null && parent != cn.getOuterClass(); parent = parent.getOuterClass()) {
+ level++;
+ }
+
+ // if constructor call is not in outer class, don't pass 'this' implicitly. Return.
+ if (parent == null) return;
+
+ //add this parameter to node
+ Expression argsExp = call.getArguments();
+ if (argsExp instanceof TupleExpression) {
+ TupleExpression argsListExp = (TupleExpression) argsExp;
+ Expression this0 = VariableExpression.THIS_EXPRESSION;
+ for (int i = 0; i != level; ++i)
+ this0 = new PropertyExpression(this0, "this$0");
+ argsListExp.getExpressions().add(0, this0);
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/groovy/blob/b25d0e55/src/main/java/org/codehaus/groovy/classgen/InnerClassVisitorHelper.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/codehaus/groovy/classgen/InnerClassVisitorHelper.java b/src/main/java/org/codehaus/groovy/classgen/InnerClassVisitorHelper.java
new file mode 100644
index 0000000..7ed0629
--- /dev/null
+++ b/src/main/java/org/codehaus/groovy/classgen/InnerClassVisitorHelper.java
@@ -0,0 +1,143 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.codehaus.groovy.classgen;
+
+import org.codehaus.groovy.ast.ClassCodeVisitorSupport;
+import org.codehaus.groovy.ast.ClassHelper;
+import org.codehaus.groovy.ast.ClassNode;
+import org.codehaus.groovy.ast.FieldNode;
+import org.codehaus.groovy.ast.InnerClassNode;
+import org.codehaus.groovy.ast.Parameter;
+import org.codehaus.groovy.ast.VariableScope;
+import org.codehaus.groovy.ast.expr.ArgumentListExpression;
+import org.codehaus.groovy.ast.expr.BinaryExpression;
+import org.codehaus.groovy.ast.expr.ConstantExpression;
+import org.codehaus.groovy.ast.expr.Expression;
+import org.codehaus.groovy.ast.expr.FieldExpression;
+import org.codehaus.groovy.ast.expr.GStringExpression;
+import org.codehaus.groovy.ast.expr.MethodCallExpression;
+import org.codehaus.groovy.ast.expr.PropertyExpression;
+import org.codehaus.groovy.ast.expr.SpreadExpression;
+import org.codehaus.groovy.ast.expr.VariableExpression;
+import org.codehaus.groovy.ast.stmt.BlockStatement;
+import org.codehaus.groovy.ast.stmt.ExpressionStatement;
+import org.codehaus.groovy.ast.stmt.ReturnStatement;
+import org.codehaus.groovy.syntax.Token;
+import org.codehaus.groovy.syntax.Types;
+import org.objectweb.asm.Opcodes;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public abstract class InnerClassVisitorHelper extends ClassCodeVisitorSupport {
+ protected static void setPropertyGetterDispatcher(BlockStatement block, Expression thiz, Parameter[] parameters) {
+ List<ConstantExpression> gStringStrings = new ArrayList<ConstantExpression>();
+ gStringStrings.add(new ConstantExpression(""));
+ gStringStrings.add(new ConstantExpression(""));
+ List<Expression> gStringValues = new ArrayList<Expression>();
+ gStringValues.add(new VariableExpression(parameters[0]));
+ block.addStatement(
+ new ReturnStatement(
+ new PropertyExpression(
+ thiz,
+ new GStringExpression("$name", gStringStrings, gStringValues)
+ )
+ )
+ );
+ }
+
+ protected static void setPropertySetterDispatcher(BlockStatement block, Expression thiz, Parameter[] parameters) {
+ List<ConstantExpression> gStringStrings = new ArrayList<ConstantExpression>();
+ gStringStrings.add(new ConstantExpression(""));
+ gStringStrings.add(new ConstantExpression(""));
+ List<Expression> gStringValues = new ArrayList<Expression>();
+ gStringValues.add(new VariableExpression(parameters[0]));
+ block.addStatement(
+ new ExpressionStatement(
+ new BinaryExpression(
+ new PropertyExpression(
+ thiz,
+ new GStringExpression("$name", gStringStrings, gStringValues)
+ ),
+ Token.newSymbol(Types.ASSIGN, -1, -1),
+ new VariableExpression(parameters[1])
+ )
+ )
+ );
+ }
+
+ protected static void setMethodDispatcherCode(BlockStatement block, Expression thiz, Parameter[] parameters) {
+ List<ConstantExpression> gStringStrings = new ArrayList<ConstantExpression>();
+ gStringStrings.add(new ConstantExpression(""));
+ gStringStrings.add(new ConstantExpression(""));
+ List<Expression> gStringValues = new ArrayList<Expression>();
+ gStringValues.add(new VariableExpression(parameters[0]));
+ block.addStatement(
+ new ReturnStatement(
+ new MethodCallExpression(
+ thiz,
+ new GStringExpression("$name", gStringStrings, gStringValues),
+ new ArgumentListExpression(
+ new SpreadExpression(new VariableExpression(parameters[1]))
+ )
+ )
+ )
+ );
+ }
+
+ protected static boolean isStatic(InnerClassNode node) {
+ VariableScope scope = node.getVariableScope();
+ if (scope != null) return scope.isInStaticContext();
+ return (node.getModifiers() & Opcodes.ACC_STATIC) != 0;
+ }
+
+ protected static ClassNode getClassNode(ClassNode node, boolean isStatic) {
+ if (isStatic) node = ClassHelper.CLASS_Type;
+ return node;
+ }
+
+ protected static int getObjectDistance(ClassNode node) {
+ int count = 0;
+ while (node != null && node != ClassHelper.OBJECT_TYPE) {
+ count++;
+ node = node.getSuperClass();
+ }
+ return count;
+ }
+
+ protected static void addFieldInit(Parameter p, FieldNode fn, BlockStatement block) {
+ VariableExpression ve = new VariableExpression(p);
+ FieldExpression fe = new FieldExpression(fn);
+ block.addStatement(new ExpressionStatement(
+ new BinaryExpression(fe, Token.newSymbol(Types.ASSIGN, -1, -1), ve)
+ ));
+ }
+
+ protected static boolean shouldHandleImplicitThisForInnerClass(ClassNode cn) {
+ if (cn.isEnum() || cn.isInterface()) return false;
+ if ((cn.getModifiers() & Opcodes.ACC_STATIC) != 0) return false;
+
+ if (!(cn instanceof InnerClassNode)) return false;
+ InnerClassNode innerClass = (InnerClassNode) cn;
+ // scope != null means aic, we don't handle that here
+ if (innerClass.getVariableScope() != null) return false;
+ // static inner classes don't need this$0
+ return (innerClass.getModifiers() & Opcodes.ACC_STATIC) == 0;
+ }
+}
http://git-wip-us.apache.org/repos/asf/groovy/blob/b25d0e55/src/main/java/org/codehaus/groovy/classgen/ReturnAdder.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/codehaus/groovy/classgen/ReturnAdder.java b/src/main/java/org/codehaus/groovy/classgen/ReturnAdder.java
new file mode 100644
index 0000000..22f3059
--- /dev/null
+++ b/src/main/java/org/codehaus/groovy/classgen/ReturnAdder.java
@@ -0,0 +1,279 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.codehaus.groovy.classgen;
+
+import org.codehaus.groovy.ast.ClassHelper;
+import org.codehaus.groovy.ast.MethodNode;
+import org.codehaus.groovy.ast.VariableScope;
+import org.codehaus.groovy.ast.expr.ConstantExpression;
+import org.codehaus.groovy.ast.expr.Expression;
+import org.codehaus.groovy.ast.stmt.BlockStatement;
+import org.codehaus.groovy.ast.stmt.BreakStatement;
+import org.codehaus.groovy.ast.stmt.CaseStatement;
+import org.codehaus.groovy.ast.stmt.CatchStatement;
+import org.codehaus.groovy.ast.stmt.EmptyStatement;
+import org.codehaus.groovy.ast.stmt.ExpressionStatement;
+import org.codehaus.groovy.ast.stmt.IfStatement;
+import org.codehaus.groovy.ast.stmt.ReturnStatement;
+import org.codehaus.groovy.ast.stmt.Statement;
+import org.codehaus.groovy.ast.stmt.SwitchStatement;
+import org.codehaus.groovy.ast.stmt.SynchronizedStatement;
+import org.codehaus.groovy.ast.stmt.ThrowStatement;
+import org.codehaus.groovy.ast.stmt.TryCatchStatement;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Utility class to add return statements.
+ * Extracted from Verifier as it can be useful for some AST transformations
+ */
+public class ReturnAdder {
+
+ private static final ReturnStatementListener DEFAULT_LISTENER = new ReturnStatementListener() {
+ public void returnStatementAdded(final ReturnStatement returnStatement) {
+ }
+ };
+
+ /**
+ * If set to 'true', then returns are effectively added. This is useful whenever you just want
+ * to check what returns are produced without eventually adding them.
+ */
+ private final boolean doAdd;
+
+ private final ReturnStatementListener listener;
+
+ public ReturnAdder() {
+ doAdd = true;
+ listener = DEFAULT_LISTENER;
+ }
+
+ public ReturnAdder(ReturnStatementListener listener) {
+ this.listener = listener;
+ this.doAdd = false;
+ }
+
+ /**
+ * Adds return statements in method code whenever an implicit return is detected.
+ * @param node the method node where to add return statements
+ * @deprecated Use {@link #visitMethod(org.codehaus.groovy.ast.MethodNode)} instead
+ */
+ @Deprecated
+ public static void addReturnIfNeeded(MethodNode node) {
+ ReturnAdder adder = new ReturnAdder();
+ adder.visitMethod(node);
+ }
+
+ public void visitMethod(MethodNode node) {
+ Statement statement = node.getCode();
+ if (!node.isVoidMethod()) {
+ if (statement != null) // it happens with @interface methods
+ {
+ final Statement code = addReturnsIfNeeded(statement, node.getVariableScope());
+ if (doAdd) node.setCode(code);
+ }
+ } else if (!node.isAbstract() && node.getReturnType().redirect()!=ClassHelper.VOID_TYPE) {
+ if (!(statement instanceof BytecodeSequence)) {
+ BlockStatement newBlock = new BlockStatement();
+ Statement code = node.getCode();
+ if (code instanceof BlockStatement) {
+ newBlock.setVariableScope(((BlockStatement) code).getVariableScope());
+ }
+ if (statement instanceof BlockStatement) {
+ newBlock.addStatements(((BlockStatement)statement).getStatements());
+ } else {
+ newBlock.addStatement(statement);
+ }
+ final ReturnStatement returnStatement = ReturnStatement.RETURN_NULL_OR_VOID;
+ listener.returnStatementAdded(returnStatement);
+ newBlock.addStatement(returnStatement);
+ newBlock.setSourcePosition(statement);
+ if (doAdd) node.setCode(newBlock);
+ }
+ }
+ }
+
+ private Statement addReturnsIfNeeded(Statement statement, VariableScope scope) {
+ if ( statement instanceof ReturnStatement
+ || statement instanceof BytecodeSequence
+ || statement instanceof ThrowStatement)
+ {
+ return statement;
+ }
+
+ if (statement instanceof EmptyStatement) {
+ final ReturnStatement returnStatement = new ReturnStatement(ConstantExpression.NULL);
+ listener.returnStatementAdded(returnStatement);
+ return returnStatement;
+ }
+
+ if (statement instanceof ExpressionStatement) {
+ ExpressionStatement expStmt = (ExpressionStatement) statement;
+ Expression expr = expStmt.getExpression();
+ ReturnStatement ret = new ReturnStatement(expr);
+ ret.setSourcePosition(expr);
+ ret.setStatementLabel(statement.getStatementLabel());
+ listener.returnStatementAdded(ret);
+ return ret;
+ }
+
+ if (statement instanceof SynchronizedStatement) {
+ SynchronizedStatement sync = (SynchronizedStatement) statement;
+ final Statement code = addReturnsIfNeeded(sync.getCode(), scope);
+ if (doAdd) sync.setCode(code);
+ return sync;
+ }
+
+ if (statement instanceof IfStatement) {
+ IfStatement ifs = (IfStatement) statement;
+ final Statement ifBlock = addReturnsIfNeeded(ifs.getIfBlock(), scope);
+ final Statement elseBlock = addReturnsIfNeeded(ifs.getElseBlock(), scope);
+ if (doAdd) {
+ ifs.setIfBlock(ifBlock);
+ ifs.setElseBlock(elseBlock);
+ }
+ return ifs;
+ }
+
+ if (statement instanceof SwitchStatement) {
+ SwitchStatement swi = (SwitchStatement) statement;
+ for (CaseStatement caseStatement : swi.getCaseStatements()) {
+ final Statement code = adjustSwitchCaseCode(caseStatement.getCode(), scope, false);
+ if (doAdd) caseStatement.setCode(code);
+ }
+ final Statement defaultStatement = adjustSwitchCaseCode(swi.getDefaultStatement(), scope, true);
+ if (doAdd) swi.setDefaultStatement(defaultStatement);
+ return swi;
+ }
+
+ if (statement instanceof TryCatchStatement) {
+ TryCatchStatement trys = (TryCatchStatement) statement;
+ final boolean[] missesReturn = new boolean[1];
+ new ReturnAdder(new ReturnStatementListener() {
+ @Override
+ public void returnStatementAdded(ReturnStatement returnStatement) {
+ missesReturn[0] = true;
+ }
+ }).addReturnsIfNeeded(trys.getFinallyStatement(), scope);
+ boolean hasFinally = !(trys.getFinallyStatement() instanceof EmptyStatement);
+
+ // if there is no missing return in the finally block and the block exists
+ // there is nothing to do
+ if (hasFinally && !missesReturn[0]) return trys;
+
+ // add returns to try and catch blocks
+ final Statement tryStatement = addReturnsIfNeeded(trys.getTryStatement(), scope);
+ if (doAdd) trys.setTryStatement(tryStatement);
+ final int len = trys.getCatchStatements().size();
+ for (int i = 0; i != len; ++i) {
+ final CatchStatement catchStatement = trys.getCatchStatement(i);
+ final Statement code = addReturnsIfNeeded(catchStatement.getCode(), scope);
+ if (doAdd) catchStatement.setCode(code);
+ }
+ return trys;
+ }
+
+ if (statement instanceof BlockStatement) {
+ BlockStatement block = (BlockStatement) statement;
+
+ final List list = block.getStatements();
+ if (!list.isEmpty()) {
+ int idx = list.size() - 1;
+ Statement last = addReturnsIfNeeded((Statement) list.get(idx), block.getVariableScope());
+ if (doAdd) list.set(idx, last);
+ if (!statementReturns(last)) {
+ final ReturnStatement returnStatement = new ReturnStatement(ConstantExpression.NULL);
+ listener.returnStatementAdded(returnStatement);
+ if (doAdd) list.add(returnStatement);
+ }
+ } else {
+ ReturnStatement ret = new ReturnStatement(ConstantExpression.NULL);
+ ret.setSourcePosition(block);
+ listener.returnStatementAdded(ret);
+ return ret;
+ }
+
+ BlockStatement newBlock = new BlockStatement(list, block.getVariableScope());
+ newBlock.setSourcePosition(block);
+ return newBlock;
+ }
+
+ if (statement == null) {
+ final ReturnStatement returnStatement = new ReturnStatement(ConstantExpression.NULL);
+ listener.returnStatementAdded(returnStatement);
+ return returnStatement;
+ } else {
+ final List list = new ArrayList();
+ list.add(statement);
+ final ReturnStatement returnStatement = new ReturnStatement(ConstantExpression.NULL);
+ listener.returnStatementAdded(returnStatement);
+ list.add(returnStatement);
+
+ BlockStatement newBlock = new BlockStatement(list, new VariableScope(scope));
+ newBlock.setSourcePosition(statement);
+ return newBlock;
+ }
+ }
+
+ private Statement adjustSwitchCaseCode(Statement statement, VariableScope scope, boolean defaultCase) {
+ if(statement instanceof BlockStatement) {
+ final List list = ((BlockStatement)statement).getStatements();
+ if (!list.isEmpty()) {
+ int idx = list.size() - 1;
+ Statement last = (Statement) list.get(idx);
+ if(last instanceof BreakStatement) {
+ if (doAdd) {
+ list.remove(idx);
+ return addReturnsIfNeeded(statement, scope);
+ } else {
+ BlockStatement newStmt = new BlockStatement();
+ for (int i=0;i<idx; i++) {
+ newStmt.addStatement((Statement) list.get(i));
+ }
+ return addReturnsIfNeeded(newStmt, scope);
+ }
+ } else if(defaultCase) {
+ return addReturnsIfNeeded(statement, scope);
+ }
+ }
+ }
+ return statement;
+ }
+
+ private static boolean statementReturns(Statement last) {
+ return (
+ last instanceof ReturnStatement ||
+ last instanceof BlockStatement ||
+ last instanceof IfStatement ||
+ last instanceof ExpressionStatement ||
+ last instanceof EmptyStatement ||
+ last instanceof TryCatchStatement ||
+ last instanceof BytecodeSequence ||
+ last instanceof ThrowStatement ||
+ last instanceof SynchronizedStatement
+ );
+ }
+
+ /**
+ * Implement this method in order to be notified whenever a return statement is generated.
+ */
+ public interface ReturnStatementListener {
+ void returnStatementAdded(ReturnStatement returnStatement);
+ }
+}