Java tutorial
/* * 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 groovy.lang.GroovyClassLoader; import groovy.lang.GroovyObject; import groovy.lang.GroovyRuntimeException; import groovy.lang.MetaClass; import groovy.transform.Generated; import groovy.transform.Internal; import org.apache.groovy.ast.tools.ClassNodeUtils; import org.apache.groovy.util.BeanUtils; import org.codehaus.groovy.GroovyBugError; import org.codehaus.groovy.ast.ASTNode; import org.codehaus.groovy.ast.AnnotationNode; import org.codehaus.groovy.ast.ClassHelper; import org.codehaus.groovy.ast.ClassNode; import org.codehaus.groovy.ast.CodeVisitorSupport; import org.codehaus.groovy.ast.ConstructorNode; import org.codehaus.groovy.ast.DynamicVariable; import org.codehaus.groovy.ast.FieldNode; import org.codehaus.groovy.ast.GenericsType; import org.codehaus.groovy.ast.GroovyClassVisitor; import org.codehaus.groovy.ast.GroovyCodeVisitor; 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.Variable; 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.CastExpression; import org.codehaus.groovy.ast.expr.ClosureExpression; import org.codehaus.groovy.ast.expr.ConstantExpression; import org.codehaus.groovy.ast.expr.ConstructorCallExpression; import org.codehaus.groovy.ast.expr.Expression; import org.codehaus.groovy.ast.expr.FieldExpression; import org.codehaus.groovy.ast.expr.MethodCallExpression; 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.ast.stmt.Statement; import org.codehaus.groovy.classgen.asm.BytecodeHelper; import org.codehaus.groovy.classgen.asm.MopWriter; import org.codehaus.groovy.classgen.asm.OptimizingStatementWriter.ClassNodeSkip; import org.codehaus.groovy.classgen.asm.WriterController; import org.codehaus.groovy.reflection.ClassInfo; import org.codehaus.groovy.syntax.RuntimeParserException; import org.codehaus.groovy.syntax.Token; import org.codehaus.groovy.syntax.Types; import org.codehaus.groovy.transform.trait.Traits; import org.objectweb.asm.Label; import org.objectweb.asm.MethodVisitor; import org.objectweb.asm.Opcodes; import java.lang.reflect.Field; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.ListIterator; import java.util.Map; import java.util.Set; import static java.lang.reflect.Modifier.isFinal; import static java.lang.reflect.Modifier.isPrivate; import static java.lang.reflect.Modifier.isPublic; import static java.lang.reflect.Modifier.isStatic; import static java.util.stream.Collectors.joining; import static org.apache.groovy.ast.tools.AnnotatedNodeUtils.markAsGenerated; import static org.apache.groovy.ast.tools.ExpressionUtils.transformInlineConstants; import static org.apache.groovy.ast.tools.MethodNodeUtils.getPropertyName; import static org.apache.groovy.ast.tools.MethodNodeUtils.methodDescriptorWithoutReturnType; import static org.codehaus.groovy.ast.tools.GeneralUtils.callThisX; import static org.codehaus.groovy.ast.tools.GeneralUtils.castX; import static org.codehaus.groovy.ast.tools.GeneralUtils.declS; import static org.codehaus.groovy.ast.tools.GeneralUtils.localVarX; import static org.codehaus.groovy.ast.tools.GeneralUtils.varX; import static org.codehaus.groovy.ast.tools.GenericsUtils.addMethodGenerics; import static org.codehaus.groovy.ast.tools.GenericsUtils.correctToGenericsSpec; import static org.codehaus.groovy.ast.tools.GenericsUtils.createGenericsSpec; import static org.codehaus.groovy.ast.tools.PropertyNodeUtils.adjustPropertyModifiersForMethod; /** * Verifies the AST node and adds any default AST code before bytecode generation occurs. * <p> * Checks include: * <ul> * <li>Methods with duplicate signatures</li> * <li>Duplicate interfaces</li> * <li>Reassigned final variables/parameters</li> * <li>Uninitialized variables</li> * <li>Bad code in object initializers or constructors</li> * <li>Mismatches in modifiers or return types between implementations and interfaces/abstract classes</li> * </ul> * * Added code includes: * <ul> * <li>Methods needed to implement GroovyObject</li> * <li>Property accessor methods</li> * <li>Covariant methods</li> * <li>Additional methods/constructors as needed for default parameters</li> * </ul> */ public class Verifier implements GroovyClassVisitor, Opcodes { public static final String STATIC_METACLASS_BOOL = "__$stMC"; public static final String SWAP_INIT = "__$swapInit"; public static final String INITIAL_EXPRESSION = "INITIAL_EXPRESSION"; public static final String DEFAULT_PARAMETER_GENERATED = "DEFAULT_PARAMETER_GENERATED"; // NOTE: timeStamp constants shouldn't belong to Verifier but kept here // for binary compatibility public static final String __TIMESTAMP = "__timeStamp"; public static final String __TIMESTAMP__ = "__timeStamp__239_neverHappen"; private static final Parameter[] SET_METACLASS_PARAMS = new Parameter[] { new Parameter(ClassHelper.METACLASS_TYPE, "mc") }; private static final Class<?> GENERATED_ANNOTATION = Generated.class; private static final Class<?> INTERNAL_ANNOTATION = Internal.class; private ClassNode classNode; private MethodNode methodNode; public ClassNode getClassNode() { return classNode; } protected void setClassNode(ClassNode classNode) { this.classNode = classNode; } public MethodNode getMethodNode() { return methodNode; } private static FieldNode setMetaClassFieldIfNotExists(ClassNode node, FieldNode metaClassField) { if (metaClassField != null) return metaClassField; final String classInternalName = BytecodeHelper.getClassInternalName(node); metaClassField = node.addField("metaClass", ACC_PRIVATE | ACC_TRANSIENT | ACC_SYNTHETIC, ClassHelper.METACLASS_TYPE, new BytecodeExpression(ClassHelper.METACLASS_TYPE) { @Override public void visit(MethodVisitor mv) { mv.visitVarInsn(ALOAD, 0); mv.visitMethodInsn(INVOKEVIRTUAL, classInternalName, "$getStaticMetaClass", "()Lgroovy/lang/MetaClass;", false); } }); metaClassField.setSynthetic(true); return metaClassField; } private static FieldNode getMetaClassField(ClassNode node) { FieldNode ret = node.getDeclaredField("metaClass"); if (ret != null) { ClassNode mcFieldType = ret.getType(); if (!mcFieldType.equals(ClassHelper.METACLASS_TYPE)) { throw new RuntimeParserException( "The class " + node.getName() + " cannot declare field 'metaClass' of type " + mcFieldType.getName() + " as it needs to be of " + "the type " + ClassHelper.METACLASS_TYPE.getName() + " for internal groovy purposes", ret); } return ret; } ClassNode current = node; while (current != ClassHelper.OBJECT_TYPE) { current = current.getSuperClass(); if (current == null) break; ret = current.getDeclaredField("metaClass"); if (ret == null) continue; if (isPrivate(ret.getModifiers())) continue; return ret; } return null; } @Override public void visitClass(final ClassNode node) { this.classNode = node; if (Traits.isTrait(node) // maybe possible to have this true in joint compilation mode || classNode.isInterface()) { //interfaces have no constructors, but this code expects one, //so create a dummy and don't add it to the class node ConstructorNode dummy = new ConstructorNode(0, null); addInitialization(node, dummy); node.visitContents(this); if (classNode.getNodeMetaData(ClassNodeSkip.class) == null) { classNode.setNodeMetaData(ClassNodeSkip.class, true); } return; } ClassNode[] classNodes = classNode.getInterfaces(); List<String> interfaces = new ArrayList<String>(); for (ClassNode classNode : classNodes) { interfaces.add(classNode.getName()); } Set<String> interfaceSet = new HashSet<String>(interfaces); if (interfaceSet.size() != interfaces.size()) { throw new RuntimeParserException("Duplicate interfaces in implements list: " + interfaces, classNode); } addDefaultParameterMethods(node); addDefaultParameterConstructors(node); final String classInternalName = BytecodeHelper.getClassInternalName(node); addStaticMetaClassField(node, classInternalName); boolean knownSpecialCase = node.isDerivedFrom(ClassHelper.GSTRING_TYPE) || node.isDerivedFrom(ClassHelper.GROOVY_OBJECT_SUPPORT_TYPE); addFastPathHelperFieldsAndHelperMethod(node, classInternalName, knownSpecialCase); if (!knownSpecialCase) addGroovyObjectInterfaceAndMethods(node, classInternalName); addDefaultConstructor(node); addInitialization(node); checkReturnInObjectInitializer(node.getObjectInitializerStatements()); node.getObjectInitializerStatements().clear(); node.visitContents(this); checkForDuplicateMethods(node); addCovariantMethods(node); checkFinalVariables(node); } private void checkFinalVariables(ClassNode node) { FinalVariableAnalyzer analyzer = new FinalVariableAnalyzer(null, getFinalVariablesCallback()); analyzer.visitClass(node); } protected FinalVariableAnalyzer.VariableNotFinalCallback getFinalVariablesCallback() { return new FinalVariableAnalyzer.VariableNotFinalCallback() { @Override public void variableNotFinal(Variable var, Expression bexp) { if (var instanceof VariableExpression) { var = ((VariableExpression) var).getAccessedVariable(); } if (var instanceof VariableExpression && isFinal(var.getModifiers())) { throw new RuntimeParserException( "The variable [" + var.getName() + "] is declared final but is reassigned", bexp); } if (var instanceof Parameter && isFinal(var.getModifiers())) { throw new RuntimeParserException( "The parameter [" + var.getName() + "] is declared final but is reassigned", bexp); } } @Override public void variableNotAlwaysInitialized(final VariableExpression var) { if (isFinal(var.getAccessedVariable().getModifiers())) throw new RuntimeParserException("The variable [" + var.getName() + "] may be uninitialized", var); } }; } private static void checkForDuplicateMethods(ClassNode cn) { Set<String> descriptors = new HashSet<String>(); for (MethodNode mn : cn.getMethods()) { if (mn.isSynthetic()) continue; String mySig = methodDescriptorWithoutReturnType(mn); if (descriptors.contains(mySig)) { if (mn.isScriptBody() || mySig.equals(scriptBodySignatureWithoutReturnType(cn))) { throw new RuntimeParserException( "The method " + mn.getText() + " is a duplicate of the one declared for this script's body code", sourceOf(mn)); } else { throw new RuntimeParserException( "The method " + mn.getText() + " duplicates another method of the same signature", sourceOf(mn)); } } descriptors.add(mySig); } } private static String scriptBodySignatureWithoutReturnType(ClassNode cn) { for (MethodNode mn : cn.getMethods()) { if (mn.isScriptBody()) return methodDescriptorWithoutReturnType(mn); } return null; } private static FieldNode checkFieldDoesNotExist(ClassNode node, String fieldName) { FieldNode ret = node.getDeclaredField(fieldName); if (ret != null) { if (isPublic(ret.getModifiers()) && ret.getType().redirect() == ClassHelper.boolean_TYPE) { return ret; } throw new RuntimeParserException("The class " + node.getName() + " cannot declare field '" + fieldName + "' as this" + " field is needed for internal groovy purposes", ret); } return null; } private static void addFastPathHelperFieldsAndHelperMethod(ClassNode node, final String classInternalName, boolean knownSpecialCase) { if (node.getNodeMetaData(ClassNodeSkip.class) != null) return; FieldNode stMCB = checkFieldDoesNotExist(node, STATIC_METACLASS_BOOL); if (stMCB == null) { stMCB = node.addField(STATIC_METACLASS_BOOL, ACC_PUBLIC | ACC_STATIC | ACC_SYNTHETIC | ACC_TRANSIENT, ClassHelper.boolean_TYPE, null); stMCB.setSynthetic(true); } } protected void addDefaultConstructor(ClassNode node) { if (!node.getDeclaredConstructors().isEmpty()) return; ConstructorNode constructor = new ConstructorNode(ACC_PUBLIC, new BlockStatement()); constructor.setHasNoRealSourcePosition(true); markAsGenerated(node, constructor); node.addConstructor(constructor); } private void addStaticMetaClassField(final ClassNode node, final String classInternalName) { String _staticClassInfoFieldName = "$staticClassInfo"; while (node.getDeclaredField(_staticClassInfoFieldName) != null) _staticClassInfoFieldName = _staticClassInfoFieldName + "$"; final String staticMetaClassFieldName = _staticClassInfoFieldName; FieldNode staticMetaClassField = node.addField(staticMetaClassFieldName, ACC_PRIVATE | ACC_STATIC | ACC_SYNTHETIC, ClassHelper.make(ClassInfo.class, false), null); staticMetaClassField.setSynthetic(true); node.addSyntheticMethod("$getStaticMetaClass", ACC_PROTECTED, ClassHelper.make(MetaClass.class), Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, new BytecodeSequence(new BytecodeInstruction() { @Override public void visit(MethodVisitor mv) { mv.visitVarInsn(ALOAD, 0); mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Object", "getClass", "()Ljava/lang/Class;", false); if (BytecodeHelper.isClassLiteralPossible(node) || BytecodeHelper.isSameCompilationUnit(classNode, node)) { BytecodeHelper.visitClassLiteral(mv, node); } else { mv.visitMethodInsn(INVOKESTATIC, classInternalName, "$get$$class$" + classInternalName.replaceAll("/", "\\$"), "()Ljava/lang/Class;", false); } Label l1 = new Label(); mv.visitJumpInsn(IF_ACMPEQ, l1); mv.visitVarInsn(ALOAD, 0); mv.visitMethodInsn(INVOKESTATIC, "org/codehaus/groovy/runtime/ScriptBytecodeAdapter", "initMetaClass", "(Ljava/lang/Object;)Lgroovy/lang/MetaClass;", false); mv.visitInsn(ARETURN); mv.visitLabel(l1); mv.visitFieldInsn(GETSTATIC, classInternalName, staticMetaClassFieldName, "Lorg/codehaus/groovy/reflection/ClassInfo;"); mv.visitVarInsn(ASTORE, 1); mv.visitVarInsn(ALOAD, 1); Label l0 = new Label(); mv.visitJumpInsn(IFNONNULL, l0); mv.visitVarInsn(ALOAD, 0); mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Object", "getClass", "()Ljava/lang/Class;", false); mv.visitMethodInsn(INVOKESTATIC, "org/codehaus/groovy/reflection/ClassInfo", "getClassInfo", "(Ljava/lang/Class;)Lorg/codehaus/groovy/reflection/ClassInfo;", false); mv.visitInsn(DUP); mv.visitVarInsn(ASTORE, 1); mv.visitFieldInsn(PUTSTATIC, classInternalName, staticMetaClassFieldName, "Lorg/codehaus/groovy/reflection/ClassInfo;"); mv.visitLabel(l0); mv.visitVarInsn(ALOAD, 1); mv.visitMethodInsn(INVOKEVIRTUAL, "org/codehaus/groovy/reflection/ClassInfo", "getMetaClass", "()Lgroovy/lang/MetaClass;", false); mv.visitInsn(ARETURN); } })); } protected void addGroovyObjectInterfaceAndMethods(ClassNode node, final String classInternalName) { if (!node.isDerivedFromGroovyObject()) node.addInterface(ClassHelper.make(GroovyObject.class)); FieldNode metaClassField = getMetaClassField(node); boolean shouldAnnotate = classNode.getModule().getContext() != null; AnnotationNode generatedAnnotation = shouldAnnotate ? new AnnotationNode(ClassHelper.make(GENERATED_ANNOTATION)) : null; AnnotationNode internalAnnotation = shouldAnnotate ? new AnnotationNode(ClassHelper.make(INTERNAL_ANNOTATION)) : null; if (!node.hasMethod("getMetaClass", Parameter.EMPTY_ARRAY)) { metaClassField = setMetaClassFieldIfNotExists(node, metaClassField); MethodNode methodNode = addMethod(node, !shouldAnnotate, "getMetaClass", ACC_PUBLIC, ClassHelper.METACLASS_TYPE, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, new BytecodeSequence(new BytecodeInstruction() { @Override public void visit(MethodVisitor mv) { Label nullLabel = new Label(); /* * the code is: * if (this.metaClass==null) { * this.metaClass = this.$getStaticMetaClass() * return this.metaClass * } else { * return this.metaClass * } * with the optimization that the result of the * first this.metaClass is duped on the operand * stack and reused for the return in the else part */ mv.visitVarInsn(ALOAD, 0); mv.visitFieldInsn(GETFIELD, classInternalName, "metaClass", "Lgroovy/lang/MetaClass;"); mv.visitInsn(DUP); mv.visitJumpInsn(IFNULL, nullLabel); mv.visitInsn(ARETURN); mv.visitLabel(nullLabel); mv.visitInsn(POP); mv.visitVarInsn(ALOAD, 0); mv.visitInsn(DUP); mv.visitMethodInsn(INVOKEVIRTUAL, classInternalName, "$getStaticMetaClass", "()Lgroovy/lang/MetaClass;", false); mv.visitFieldInsn(PUTFIELD, classInternalName, "metaClass", "Lgroovy/lang/MetaClass;"); mv.visitVarInsn(ALOAD, 0); mv.visitFieldInsn(GETFIELD, classInternalName, "metaClass", "Lgroovy/lang/MetaClass;"); mv.visitInsn(ARETURN); } })); if (shouldAnnotate) { methodNode.addAnnotation(generatedAnnotation); methodNode.addAnnotation(internalAnnotation); } } Parameter[] parameters = new Parameter[] { new Parameter(ClassHelper.METACLASS_TYPE, "mc") }; if (!node.hasMethod("setMetaClass", parameters)) { metaClassField = setMetaClassFieldIfNotExists(node, metaClassField); Statement setMetaClassCode; if (isFinal(metaClassField.getModifiers())) { ConstantExpression text = new ConstantExpression("cannot set read-only meta class"); ConstructorCallExpression cce = new ConstructorCallExpression( ClassHelper.make(IllegalArgumentException.class), text); setMetaClassCode = new ExpressionStatement(cce); } else { List list = new ArrayList(); list.add(new BytecodeInstruction() { @Override public void visit(MethodVisitor mv) { /* * the code is (meta class is stored in 1): * this.metaClass = <1> */ mv.visitVarInsn(ALOAD, 0); mv.visitVarInsn(ALOAD, 1); mv.visitFieldInsn(PUTFIELD, classInternalName, "metaClass", "Lgroovy/lang/MetaClass;"); mv.visitInsn(RETURN); } }); setMetaClassCode = new BytecodeSequence(list); } MethodNode methodNode = addMethod(node, !shouldAnnotate, "setMetaClass", ACC_PUBLIC, ClassHelper.VOID_TYPE, SET_METACLASS_PARAMS, ClassNode.EMPTY_ARRAY, setMetaClassCode); if (shouldAnnotate) { methodNode.addAnnotation(generatedAnnotation); methodNode.addAnnotation(internalAnnotation); } } } /** * Helper method to add a new method to a ClassNode. Depending on the shouldBeSynthetic flag the * call will either be made to ClassNode.addSyntheticMethod() or ClassNode.addMethod(). If a non-synthetic method * is to be added the ACC_SYNTHETIC modifier is removed if it has been accidentally supplied. */ protected MethodNode addMethod(ClassNode node, boolean shouldBeSynthetic, String name, int modifiers, ClassNode returnType, Parameter[] parameters, ClassNode[] exceptions, Statement code) { if (shouldBeSynthetic) { return node.addSyntheticMethod(name, modifiers, returnType, parameters, exceptions, code); } else { return node.addMethod(name, modifiers & ~ACC_SYNTHETIC, returnType, parameters, exceptions, code); } } // for binary compatibility only, don't use or override this protected void addMethod$$bridge(ClassNode node, boolean shouldBeSynthetic, String name, int modifiers, ClassNode returnType, Parameter[] parameters, ClassNode[] exceptions, Statement code) { addMethod(node, shouldBeSynthetic, name, modifiers, returnType, parameters, exceptions, code); } @Deprecated protected void addTimeStamp(ClassNode node) { } private static void checkReturnInObjectInitializer(List<Statement> init) { GroovyCodeVisitor visitor = new CodeVisitorSupport() { @Override public void visitClosureExpression(ClosureExpression expression) { // return is OK in closures in object initializers } @Override public void visitReturnStatement(ReturnStatement statement) { throw new RuntimeParserException("'return' is not allowed in object initializer", statement); } }; for (Statement stmt : init) { stmt.visit(visitor); } } @Override public void visitConstructor(ConstructorNode node) { Statement stmt = node.getCode(); if (stmt != null) { stmt.visit(new VerifierCodeVisitor(getClassNode())); // check for uninitialized-this references stmt.visit(new CodeVisitorSupport() { @Override public void visitClosureExpression(ClosureExpression ce) { boolean oldInClosure = inClosure; inClosure = true; super.visitClosureExpression(ce); inClosure = oldInClosure; } @Override public void visitConstructorCallExpression(ConstructorCallExpression cce) { boolean oldIsSpecialConstructorCall = inSpecialConstructorCall; inSpecialConstructorCall |= cce.isSpecialCall(); super.visitConstructorCallExpression(cce); inSpecialConstructorCall = oldIsSpecialConstructorCall; } @Override public void visitMethodCallExpression(MethodCallExpression mce) { if (inSpecialConstructorCall && isThisObjectExpression(mce)) { MethodNode methodTarget = mce.getMethodTarget(); if (methodTarget == null || !(methodTarget.isStatic() || classNode.getOuterClasses().contains(methodTarget.getDeclaringClass()))) { if (!mce.isImplicitThis()) { throw newVariableError(mce.getObjectExpression().getText(), mce.getObjectExpression()); } else { throw newVariableError(mce.getMethodAsString(), mce.getMethod()); } } mce.getMethod().visit(this); mce.getArguments().visit(this); } else { super.visitMethodCallExpression(mce); } } @Override public void visitVariableExpression(VariableExpression ve) { // before this/super ctor call completes, only params and static or outer members are accessible if (inSpecialConstructorCall && (ve.isThisExpression() || ve.isSuperExpression() || isNonStaticMemberAccess(ve))) { throw newVariableError(ve.getName(), ve.getLineNumber() > 0 ? ve : node); // TODO: context for default argument } } // private boolean inClosure, inSpecialConstructorCall; private boolean isNonStaticMemberAccess(VariableExpression ve) { Variable variable = ve.getAccessedVariable(); return !inClosure && variable != null && !isStatic(variable.getModifiers()) && !(variable instanceof DynamicVariable) && !(variable instanceof Parameter); } private boolean isThisObjectExpression(MethodCallExpression mce) { if (mce.isImplicitThis()) { return true; } else if (mce.getObjectExpression() instanceof VariableExpression) { VariableExpression var = (VariableExpression) mce.getObjectExpression(); return var.isThisExpression() || var.isSuperExpression(); } else { return false; } } private GroovyRuntimeException newVariableError(String name, ASTNode node) { RuntimeParserException rpe = new RuntimeParserException("Cannot reference '" + name + "' before supertype constructor has been called. Possible causes:\n" + "You attempted to access an instance field, method, or property.\n" + "You attempted to construct a non-static inner class.", node); rpe.setModule(getClassNode().getModule()); return rpe; } }); } } @Override public void visitMethod(MethodNode node) { // GROOVY-3712 - if it's an MOP method, it's an error as they aren't supposed to exist before ACG is invoked if (MopWriter.isMopMethod(node.getName())) { throw new RuntimeParserException("Found unexpected MOP methods in the class node for " + classNode.getName() + "(" + node.getName() + ")", classNode); } adjustTypesIfStaticMainMethod(node); this.methodNode = node; addReturnIfNeeded(node); Statement stmt = node.getCode(); if (stmt != null) { stmt.visit(new VerifierCodeVisitor(getClassNode())); } } private static void adjustTypesIfStaticMainMethod(MethodNode node) { if (node.getName().equals("main") && node.isStatic()) { Parameter[] params = node.getParameters(); if (params.length == 1) { Parameter param = params[0]; if (param.getType() == null || param.getType() == ClassHelper.OBJECT_TYPE) { param.setType(ClassHelper.STRING_TYPE.makeArray()); ClassNode returnType = node.getReturnType(); if (returnType == ClassHelper.OBJECT_TYPE) { node.setReturnType(ClassHelper.VOID_TYPE); } } } } } protected void addReturnIfNeeded(MethodNode node) { ReturnAdder adder = new ReturnAdder(); adder.visitMethod(node); } @Override public void visitField(FieldNode node) { } private boolean methodNeedsReplacement(MethodNode m) { // no method found, we need to replace if (m == null) return true; // method is in current class, nothing to be done if (m.getDeclaringClass() == this.getClassNode()) return false; // do not overwrite final if (isFinal(m.getModifiers())) return false; return true; } @Override public void visitProperty(PropertyNode node) { String name = node.getName(); FieldNode field = node.getField(); String getterName = "get" + capitalize(name); String setterName = "set" + capitalize(name); int accessorModifiers = adjustPropertyModifiersForMethod(node); Statement getterBlock = node.getGetterBlock(); if (getterBlock == null) { MethodNode getter = classNode.getGetterMethod(getterName, !node.isStatic()); if (getter == null && ClassHelper.boolean_TYPE == node.getType()) { String secondGetterName = "is" + capitalize(name); getter = classNode.getGetterMethod(secondGetterName); } if (!node.isPrivate() && methodNeedsReplacement(getter)) { getterBlock = createGetterBlock(node, field); } } Statement setterBlock = node.getSetterBlock(); if (setterBlock == null) { // 2nd arg false below: though not usual, allow setter with non-void return type MethodNode setter = classNode.getSetterMethod(setterName, false); if (!node.isPrivate() && !isFinal(accessorModifiers) && methodNeedsReplacement(setter)) { setterBlock = createSetterBlock(node, field); } } int getterModifiers = accessorModifiers; // don't make static accessors final if (node.isStatic()) { getterModifiers = ~ACC_FINAL & getterModifiers; } if (getterBlock != null) { visitGetter(node, getterBlock, getterModifiers, getterName); if (ClassHelper.boolean_TYPE == node.getType() || ClassHelper.Boolean_TYPE == node.getType()) { String secondGetterName = "is" + capitalize(name); visitGetter(node, getterBlock, getterModifiers, secondGetterName); } } if (setterBlock != null) { Parameter[] setterParameterTypes = { new Parameter(node.getType(), "value") }; MethodNode setter = new MethodNode(setterName, accessorModifiers, ClassHelper.VOID_TYPE, setterParameterTypes, ClassNode.EMPTY_ARRAY, setterBlock); setter.setSynthetic(true); addPropertyMethod(setter); visitMethod(setter); } } private void visitGetter(PropertyNode node, Statement getterBlock, int getterModifiers, String getterName) { MethodNode getter = new MethodNode(getterName, getterModifiers, node.getType(), Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, getterBlock); getter.setSynthetic(true); addPropertyMethod(getter); visitMethod(getter); } protected void addPropertyMethod(MethodNode method) { classNode.addMethod(method); markAsGenerated(classNode, method); // GROOVY-4415 / GROOVY-4645: check that there's no abstract method which corresponds to this one String methodName = method.getName(); Parameter[] parameters = method.getParameters(); ClassNode methodReturnType = method.getReturnType(); for (MethodNode node : classNode.getAbstractMethods()) { if (!node.getDeclaringClass().equals(classNode)) continue; if (node.getName().equals(methodName) && node.getParameters().length == parameters.length) { if (parameters.length == 1) { // setter ClassNode abstractMethodParameterType = node.getParameters()[0].getType(); ClassNode methodParameterType = parameters[0].getType(); if (!methodParameterType.isDerivedFrom(abstractMethodParameterType) && !methodParameterType.implementsInterface(abstractMethodParameterType)) { continue; } } ClassNode nodeReturnType = node.getReturnType(); if (!methodReturnType.isDerivedFrom(nodeReturnType) && !methodReturnType.implementsInterface(nodeReturnType)) { continue; } // matching method, remove abstract status and use the same body node.setModifiers(node.getModifiers() ^ ACC_ABSTRACT); node.setCode(method.getCode()); } } } @FunctionalInterface public interface DefaultArgsAction { void call(ArgumentListExpression arguments, Parameter[] parameters, MethodNode method); } /** * Creates a new method for each combination of default parameter expressions. */ protected void addDefaultParameterMethods(ClassNode type) { List<MethodNode> methods = new ArrayList<>(type.getMethods()); addDefaultParameters(methods, (arguments, params, method) -> { BlockStatement code = new BlockStatement(); MethodNode newMethod = new MethodNode(method.getName(), method.getModifiers(), method.getReturnType(), params, method.getExceptions(), code); MethodNode oldMethod = type.getDeclaredMethod(method.getName(), params); if (oldMethod != null) { throw new RuntimeParserException("The method with default parameters \"" + method.getTypeDescriptor() + "\" defines a method \"" + newMethod.getTypeDescriptor() + "\" that is already defined.", sourceOf(method)); } List<AnnotationNode> annotations = method.getAnnotations(); if (annotations != null && !annotations.isEmpty()) { newMethod.addAnnotations(annotations); } newMethod.setGenericsTypes(method.getGenericsTypes()); // GROOVY-5632, GROOVY-9151: check for references to parameters that have been removed GroovyCodeVisitor visitor = new CodeVisitorSupport() { private boolean inClosure; @Override public void visitClosureExpression(ClosureExpression e) { boolean prev = inClosure; inClosure = true; super.visitClosureExpression(e); inClosure = prev; } @Override public void visitVariableExpression(VariableExpression e) { if (e.getAccessedVariable() instanceof Parameter) { Parameter p = (Parameter) e.getAccessedVariable(); if (p.hasInitialExpression() && !Arrays.asList(params).contains(p)) { VariableScope blockScope = code.getVariableScope(); VariableExpression localVariable = (VariableExpression) blockScope .getDeclaredVariable(p.getName()); if (localVariable == null) { // create a variable declaration so that the name can be found in the new method localVariable = localVarX(p.getName(), p.getType()); localVariable.setModifiers(p.getModifiers()); blockScope.putDeclaredVariable(localVariable); localVariable.setInStaticContext(blockScope.isInStaticContext()); code.addStatement(declS(localVariable, p.getInitialExpression())); } if (!localVariable.isClosureSharedVariable()) { localVariable.setClosureSharedVariable(inClosure); } } } } }; visitor.visitArgumentlistExpression(arguments); // if variable was created to capture an initial value expression, reference it in arguments as well for (ListIterator<Expression> it = arguments.getExpressions().listIterator(); it.hasNext();) { Expression argument = it.next(); if (argument instanceof CastExpression) { argument = ((CastExpression) argument).getExpression(); } for (Parameter p : method.getParameters()) { if (p.hasInitialExpression() && p.getInitialExpression() == argument) { if (code.getVariableScope().getDeclaredVariable(p.getName()) != null) { it.set(varX(p.getName())); } break; } } } // delegate to original method using arguments derived from defaults MethodCallExpression call = callThisX(method.getName(), arguments); call.setMethodTarget(method); call.setImplicitThis(true); if (method.isVoidMethod()) { code.addStatement(new ExpressionStatement(call)); } else { code.addStatement(new ReturnStatement(call)); } // GROOVY-5681: set anon. inner enclosing method reference visitor = new CodeVisitorSupport() { @Override public void visitConstructorCallExpression(ConstructorCallExpression call) { if (call.isUsingAnonymousInnerClass()) { call.getType().setEnclosingMethod(newMethod); } super.visitConstructorCallExpression(call); } }; visitor.visitBlockStatement(code); addPropertyMethod(newMethod); newMethod.putNodeMetaData(DEFAULT_PARAMETER_GENERATED, Boolean.TRUE); }); } /** * Creates a new constructor for each combination of default parameter expressions. */ protected void addDefaultParameterConstructors(ClassNode type) { List<ConstructorNode> constructors = new ArrayList<>(type.getDeclaredConstructors()); addDefaultParameters(constructors, (arguments, params, method) -> { // GROOVY-9151: check for references to parameters that have been removed for (ListIterator<Expression> it = arguments.getExpressions().listIterator(); it.hasNext();) { Expression argument = it.next(); if (argument instanceof CastExpression) { argument = ((CastExpression) argument).getExpression(); } if (argument instanceof VariableExpression) { VariableExpression v = (VariableExpression) argument; if (v.getAccessedVariable() instanceof Parameter) { Parameter p = (Parameter) v.getAccessedVariable(); if (p.hasInitialExpression() && !Arrays.asList(params).contains(p) && p.getInitialExpression() instanceof ConstantExpression) { // replace argument "(Type) param" with "(Type) <param's default>" for simple default value it.set(castX(method.getParameters()[it.nextIndex() - 1].getType(), p.getInitialExpression())); } } } } GroovyCodeVisitor visitor = new CodeVisitorSupport() { @Override public void visitVariableExpression(VariableExpression e) { if (e.getAccessedVariable() instanceof Parameter) { Parameter p = (Parameter) e.getAccessedVariable(); if (p.hasInitialExpression() && !Arrays.asList(params).contains(p)) { String error = String.format( "The generated constructor \"%s(%s)\" references parameter '%s' which has been replaced by a default value expression.", type.getNameWithoutPackage(), Arrays.stream(params).map(Parameter::getType) .map(ClassNodeUtils::formatTypeName).collect(joining(",")), p.getName()); throw new RuntimeParserException(error, sourceOf(method)); } } } }; visitor.visitArgumentlistExpression(arguments); // delegate to original constructor using arguments derived from defaults Statement code = new ExpressionStatement(new ConstructorCallExpression(ClassNode.THIS, arguments)); addConstructor(params, (ConstructorNode) method, code, type); }); } protected void addConstructor(Parameter[] newParams, ConstructorNode ctor, Statement code, ClassNode type) { ConstructorNode newConstructor = type.addConstructor(ctor.getModifiers(), newParams, ctor.getExceptions(), code); newConstructor.putNodeMetaData(DEFAULT_PARAMETER_GENERATED, Boolean.TRUE); markAsGenerated(type, newConstructor); // TODO: Copy annotations, etc.? // set anon. inner enclosing method reference code.visit(new CodeVisitorSupport() { @Override public void visitConstructorCallExpression(ConstructorCallExpression call) { if (call.isUsingAnonymousInnerClass()) { call.getType().setEnclosingMethod(newConstructor); } super.visitConstructorCallExpression(call); } }); } /** * Creates a new helper method for each combination of default parameter expressions. */ protected void addDefaultParameters(List<? extends MethodNode> methods, DefaultArgsAction action) { for (MethodNode method : methods) { if (method.hasDefaultValue()) { addDefaultParameters(action, method); } } } protected void addDefaultParameters(DefaultArgsAction action, MethodNode method) { Parameter[] parameters = method.getParameters(); long n = Arrays.stream(parameters).filter(Parameter::hasInitialExpression).count(); for (int i = 1; i <= n; i += 1) { Parameter[] newParams = new Parameter[parameters.length - i]; ArgumentListExpression arguments = new ArgumentListExpression(); int index = 0; int j = 1; for (Parameter parameter : parameters) { if (parameter == null) { throw new GroovyBugError("Parameter should not be null for method " + methodNode.getName()); } else { Expression e; if (j > n - i && parameter.hasInitialExpression()) { e = parameter.getInitialExpression(); } else { newParams[index++] = parameter; e = varX(parameter); } arguments.addExpression(castX(parameter.getType(), e)); if (parameter.hasInitialExpression()) j += 1; } } action.call(arguments, newParams, method); } for (Parameter parameter : parameters) { if (parameter.hasInitialExpression()) { // remove default expression and store it as node metadata parameter.putNodeMetaData(Verifier.INITIAL_EXPRESSION, parameter.getInitialExpression()); parameter.setInitialExpression(null); } } } protected void addClosureCode(InnerClassNode node) { // add a new invoke } protected void addInitialization(final ClassNode node) { boolean addSwapInit = moveOptimizedConstantsInitialization(node); for (ConstructorNode cn : node.getDeclaredConstructors()) { addInitialization(node, cn); } if (addSwapInit) { BytecodeSequence seq = new BytecodeSequence(new BytecodeInstruction() { @Override public void visit(MethodVisitor mv) { mv.visitMethodInsn(INVOKESTATIC, BytecodeHelper.getClassInternalName(node), SWAP_INIT, "()V", false); } }); List<Statement> swapCall = new ArrayList<Statement>(1); swapCall.add(seq); node.addStaticInitializerStatements(swapCall, true); } } protected void addInitialization(ClassNode node, ConstructorNode constructorNode) { Statement firstStatement = constructorNode.getFirstStatement(); // if some transformation decided to generate constructor then it probably knows who it does if (firstStatement instanceof BytecodeSequence) return; ConstructorCallExpression first = getFirstIfSpecialConstructorCall(firstStatement); // in case of this(...) let the other constructor do the init if (first != null && (first.isThisCall())) return; List<Statement> statements = new ArrayList<Statement>(); List<Statement> staticStatements = new ArrayList<Statement>(); final boolean isEnum = node.isEnum(); List<Statement> initStmtsAfterEnumValuesInit = new ArrayList<Statement>(); Set<String> explicitStaticPropsInEnum = new HashSet<String>(); if (isEnum) { for (PropertyNode propNode : node.getProperties()) { if (!propNode.isSynthetic() && propNode.getField().isStatic()) { explicitStaticPropsInEnum.add(propNode.getField().getName()); } } for (FieldNode fieldNode : node.getFields()) { if (!fieldNode.isSynthetic() && fieldNode.isStatic() && fieldNode.getType() != node) { explicitStaticPropsInEnum.add(fieldNode.getName()); } } } if (!Traits.isTrait(node)) { for (FieldNode fn : node.getFields()) { addFieldInitialization(statements, staticStatements, fn, isEnum, initStmtsAfterEnumValuesInit, explicitStaticPropsInEnum); } } statements.addAll(node.getObjectInitializerStatements()); Statement code = constructorNode.getCode(); BlockStatement block = new BlockStatement(); List<Statement> otherStatements = block.getStatements(); if (code instanceof BlockStatement) { block = (BlockStatement) code; otherStatements = block.getStatements(); } else if (code != null) { otherStatements.add(code); } if (!otherStatements.isEmpty()) { if (first != null) { // it is super(..) since this(..) is already covered otherStatements.remove(0); statements.add(0, firstStatement); } Statement stmtThis$0 = getImplicitThis$0StmtIfInnerClass(otherStatements); if (stmtThis$0 != null) { // since there can be field init statements that depend on method/property dispatching // that uses this$0, it needs to bubble up before the super call itself (GROOVY-4471) statements.add(0, stmtThis$0); } statements.addAll(otherStatements); } BlockStatement newBlock = new BlockStatement(statements, block.getVariableScope()); newBlock.setSourcePosition(block); constructorNode.setCode(newBlock); if (!staticStatements.isEmpty()) { if (isEnum) { /* * GROOVY-3161: initialize statements for explicitly declared static fields * inside an enum should come after enum values are initialized */ staticStatements.removeAll(initStmtsAfterEnumValuesInit); node.addStaticInitializerStatements(staticStatements, true); if (!initStmtsAfterEnumValuesInit.isEmpty()) { node.positionStmtsAfterEnumInitStmts(initStmtsAfterEnumValuesInit); } } else { node.addStaticInitializerStatements(staticStatements, true); } } } /* * When InnerClassVisitor adds <code>this.this$0 = $p$n</code>, it adds it * as a BlockStatement having that ExpressionStatement. */ private Statement getImplicitThis$0StmtIfInnerClass(List<Statement> otherStatements) { if (!(classNode instanceof InnerClassNode)) return null; for (Statement stmt : otherStatements) { if (stmt instanceof BlockStatement) { List<Statement> stmts = ((BlockStatement) stmt).getStatements(); for (Statement bstmt : stmts) { if (bstmt instanceof ExpressionStatement) { if (extractImplicitThis$0StmtIfInnerClassFromExpression(stmts, bstmt)) return bstmt; } } } else if (stmt instanceof ExpressionStatement) { if (extractImplicitThis$0StmtIfInnerClassFromExpression(otherStatements, stmt)) return stmt; } } return null; } private static boolean extractImplicitThis$0StmtIfInnerClassFromExpression(final List<Statement> stmts, final Statement bstmt) { Expression expr = ((ExpressionStatement) bstmt).getExpression(); if (expr instanceof BinaryExpression) { Expression lExpr = ((BinaryExpression) expr).getLeftExpression(); if (lExpr instanceof FieldExpression) { if ("this$0".equals(((FieldExpression) lExpr).getFieldName())) { stmts.remove(bstmt); // remove from here and let the caller reposition it return true; } } } return false; } private static ConstructorCallExpression getFirstIfSpecialConstructorCall(Statement code) { if (!(code instanceof ExpressionStatement)) return null; Expression expression = ((ExpressionStatement) code).getExpression(); if (!(expression instanceof ConstructorCallExpression)) return null; ConstructorCallExpression cce = (ConstructorCallExpression) expression; if (cce.isSpecialCall()) return cce; return null; } protected void addFieldInitialization(List list, List staticList, FieldNode fieldNode, boolean isEnumClassNode, List initStmtsAfterEnumValuesInit, Set explicitStaticPropsInEnum) { Expression expression = fieldNode.getInitialExpression(); if (expression != null) { final FieldExpression fe = new FieldExpression(fieldNode); if (fieldNode.getType().equals(ClassHelper.REFERENCE_TYPE) && ((fieldNode.getModifiers() & ACC_SYNTHETIC) != 0)) { fe.setUseReferenceDirectly(true); } ExpressionStatement statement = new ExpressionStatement(new BinaryExpression(fe, Token.newSymbol(Types.EQUAL, fieldNode.getLineNumber(), fieldNode.getColumnNumber()), expression)); if (fieldNode.isStatic()) { // GROOVY-3311: pre-defined constants added by groovy compiler for numbers/characters should be // initialized first so that code dependent on it does not see their values as empty Expression initialValueExpression = fieldNode.getInitialValueExpression(); Expression transformed = transformInlineConstants(initialValueExpression, fieldNode.getType()); if (transformed instanceof ConstantExpression) { ConstantExpression cexp = (ConstantExpression) transformed; cexp = transformToPrimitiveConstantIfPossible(cexp); if (fieldNode.isFinal() && ClassHelper.isStaticConstantInitializerType(cexp.getType()) && cexp.getType().equals(fieldNode.getType())) { fieldNode.setInitialValueExpression(transformed); return; // GROOVY-5150: primitive type constants will be initialized directly } staticList.add(0, statement); } else { staticList.add(statement); } fieldNode.setInitialValueExpression(null); // to avoid double initialization in case of several constructors /* * If it is a statement for an explicitly declared static field inside an enum, store its * reference. For enums, they need to be handled differently as such init statements should * come after the enum values have been initialized inside <clinit> block. GROOVY-3161. */ if (isEnumClassNode && explicitStaticPropsInEnum.contains(fieldNode.getName())) { initStmtsAfterEnumValuesInit.add(statement); } } else { list.add(statement); } } } /** * Capitalizes the start of the given bean property name. */ public static String capitalize(String name) { return BeanUtils.capitalize(name); } protected Statement createGetterBlock(PropertyNode propertyNode, final FieldNode field) { return new BytecodeSequence(new BytecodeInstruction() { public void visit(MethodVisitor mv) { if (field.isStatic()) { mv.visitFieldInsn(GETSTATIC, BytecodeHelper.getClassInternalName(classNode), field.getName(), BytecodeHelper.getTypeDescription(field.getType())); } else { mv.visitVarInsn(ALOAD, 0); mv.visitFieldInsn(GETFIELD, BytecodeHelper.getClassInternalName(classNode), field.getName(), BytecodeHelper.getTypeDescription(field.getType())); } BytecodeHelper.doReturn(mv, field.getType()); } }); } protected Statement createSetterBlock(PropertyNode propertyNode, final FieldNode field) { return new BytecodeSequence(new BytecodeInstruction() { @Override public void visit(MethodVisitor mv) { if (field.isStatic()) { BytecodeHelper.load(mv, field.getType(), 0); mv.visitFieldInsn(PUTSTATIC, BytecodeHelper.getClassInternalName(classNode), field.getName(), BytecodeHelper.getTypeDescription(field.getType())); } else { mv.visitVarInsn(ALOAD, 0); BytecodeHelper.load(mv, field.getType(), 1); mv.visitFieldInsn(PUTFIELD, BytecodeHelper.getClassInternalName(classNode), field.getName(), BytecodeHelper.getTypeDescription(field.getType())); } mv.visitInsn(RETURN); } }); } public void visitGenericType(GenericsType genericsType) { } public static Long getTimestampFromFieldName(String fieldName) { if (fieldName.startsWith(__TIMESTAMP__)) { try { return Long.decode(fieldName.substring(__TIMESTAMP__.length())); } catch (NumberFormatException e) { return Long.MAX_VALUE; } } return null; } public static long getTimestamp(Class<?> clazz) { if (clazz.getClassLoader() instanceof GroovyClassLoader.InnerLoader) { GroovyClassLoader.InnerLoader innerLoader = (GroovyClassLoader.InnerLoader) clazz.getClassLoader(); return innerLoader.getTimeStamp(); } final Field[] fields = clazz.getFields(); for (int i = 0; i != fields.length; ++i) { if (isStatic(fields[i].getModifiers())) { Long timestamp = getTimestampFromFieldName(fields[i].getName()); if (timestamp != null) { return timestamp; } } } return Long.MAX_VALUE; } protected void addCovariantMethods(ClassNode classNode) { Map methodsToAdd = new HashMap(); Map genericsSpec = new HashMap(); // unimplemented abstract methods from interfaces Map<String, MethodNode> abstractMethods = ClassNodeUtils.getDeclaredMethodsFromInterfaces(classNode); Map<String, MethodNode> allInterfaceMethods = new HashMap<String, MethodNode>(abstractMethods); ClassNodeUtils.addDeclaredMethodsFromAllInterfaces(classNode, allInterfaceMethods); List<MethodNode> declaredMethods = new ArrayList<MethodNode>(classNode.getMethods()); // remove all static, private and package private methods for (Iterator methodsIterator = declaredMethods.iterator(); methodsIterator.hasNext();) { MethodNode m = (MethodNode) methodsIterator.next(); abstractMethods.remove(m.getTypeDescriptor()); if (m.isStatic() || !(m.isPublic() || m.isProtected())) { methodsIterator.remove(); } MethodNode intfMethod = allInterfaceMethods.get(m.getTypeDescriptor()); if (intfMethod != null && ((m.getModifiers() & ACC_SYNTHETIC) == 0) && !m.isPublic() && !m.isStaticConstructor()) { throw new RuntimeParserException("The method " + m.getName() + " should be public as it implements the corresponding method from interface " + intfMethod.getDeclaringClass(), sourceOf(m)); } } addCovariantMethods(classNode, declaredMethods, abstractMethods, methodsToAdd, genericsSpec); Map<String, MethodNode> declaredMethodsMap = new HashMap<String, MethodNode>(); if (!methodsToAdd.isEmpty()) { for (MethodNode mn : declaredMethods) { declaredMethodsMap.put(mn.getTypeDescriptor(), mn); } } for (Object o : methodsToAdd.entrySet()) { Map.Entry entry = (Map.Entry) o; MethodNode method = (MethodNode) entry.getValue(); // we skip bridge methods implemented in current class already MethodNode mn = declaredMethodsMap.get(entry.getKey()); if (mn != null && mn.getDeclaringClass().equals(classNode)) continue; addPropertyMethod(method); } } private void addCovariantMethods(ClassNode classNode, List declaredMethods, Map abstractMethods, Map methodsToAdd, Map oldGenericsSpec) { ClassNode sn = classNode.getUnresolvedSuperClass(false); if (sn != null) { Map genericsSpec = createGenericsSpec(sn, oldGenericsSpec); List<MethodNode> classMethods = sn.getMethods(); // original class causing bridge methods for methods in super class storeMissingCovariantMethods(declaredMethods, methodsToAdd, genericsSpec, classMethods); // super class causing bridge methods for abstract methods in original class if (!abstractMethods.isEmpty()) { for (Object classMethod : classMethods) { MethodNode method = (MethodNode) classMethod; if (method.isStatic()) continue; storeMissingCovariantMethods(abstractMethods.values(), method, methodsToAdd, Collections.EMPTY_MAP, true); } } addCovariantMethods(sn.redirect(), declaredMethods, abstractMethods, methodsToAdd, genericsSpec); } ClassNode[] interfaces = classNode.getInterfaces(); for (ClassNode anInterface : interfaces) { List interfacesMethods = anInterface.getMethods(); Map genericsSpec = createGenericsSpec(anInterface, oldGenericsSpec); storeMissingCovariantMethods(declaredMethods, methodsToAdd, genericsSpec, interfacesMethods); addCovariantMethods(anInterface, declaredMethods, abstractMethods, methodsToAdd, genericsSpec); } } private void storeMissingCovariantMethods(List declaredMethods, Map methodsToAdd, Map genericsSpec, List<MethodNode> methodNodeList) { for (Object declaredMethod : declaredMethods) { MethodNode method = (MethodNode) declaredMethod; if (method.isStatic()) continue; storeMissingCovariantMethods(methodNodeList, method, methodsToAdd, genericsSpec, false); } } private MethodNode getCovariantImplementation(final MethodNode oldMethod, final MethodNode overridingMethod, Map genericsSpec, boolean ignoreError) { // method name if (!oldMethod.getName().equals(overridingMethod.getName())) return null; if ((overridingMethod.getModifiers() & ACC_BRIDGE) != 0) return null; if (oldMethod.isPrivate()) return null; if (oldMethod.getGenericsTypes() != null) genericsSpec = addMethodGenerics(oldMethod, genericsSpec); // parameters boolean normalEqualParameters = equalParametersNormal(overridingMethod, oldMethod); boolean genericEqualParameters = equalParametersWithGenerics(overridingMethod, oldMethod, genericsSpec); if (!normalEqualParameters && !genericEqualParameters) return null; // return type ClassNode mr = overridingMethod.getReturnType(); ClassNode omr = oldMethod.getReturnType(); boolean equalReturnType = mr.equals(omr); ClassNode testmr = correctToGenericsSpec(genericsSpec, omr); if (!isAssignable(mr, testmr)) { if (ignoreError) return null; throw new RuntimeParserException( "The return type of " + overridingMethod.getTypeDescriptor() + " in " + overridingMethod.getDeclaringClass().getName() + " is incompatible with " + testmr.getName() + " in " + oldMethod.getDeclaringClass().getName(), sourceOf(overridingMethod)); } if (equalReturnType && normalEqualParameters) return null; if ((oldMethod.getModifiers() & ACC_FINAL) != 0) { throw new RuntimeParserException("Cannot override final method " + oldMethod.getTypeDescriptor() + " in " + oldMethod.getDeclaringClass().getName(), sourceOf(overridingMethod)); } if (oldMethod.isStatic() != overridingMethod.isStatic()) { throw new RuntimeParserException( "Cannot override method " + oldMethod.getTypeDescriptor() + " in " + oldMethod.getDeclaringClass().getName() + " with disparate static modifier", sourceOf(overridingMethod)); } if (!equalReturnType) { boolean oldM = ClassHelper.isPrimitiveType(oldMethod.getReturnType()); boolean newM = ClassHelper.isPrimitiveType(overridingMethod.getReturnType()); if (oldM || newM) { String message; if (oldM && newM) { message = " with old and new method having different primitive return types"; } else if (newM) { message = " with new method having a primitive return type and old method not"; } else /* oldM */ { message = " with old method having a primitive return type and new method not"; } throw new RuntimeParserException("Cannot override method " + oldMethod.getTypeDescriptor() + " in " + oldMethod.getDeclaringClass().getName() + message, sourceOf(overridingMethod)); } } // if we reach this point we have at least one parameter or return type, that // is different in its specified form. That means we have to create a bridge method! MethodNode newMethod = new MethodNode(oldMethod.getName(), overridingMethod.getModifiers() | ACC_SYNTHETIC | ACC_BRIDGE, cleanType(oldMethod.getReturnType()), cleanParameters(oldMethod.getParameters()), oldMethod.getExceptions(), null); List instructions = new ArrayList(1); instructions.add(new BytecodeInstruction() { @Override public void visit(MethodVisitor mv) { mv.visitVarInsn(ALOAD, 0); Parameter[] para = oldMethod.getParameters(); Parameter[] goal = overridingMethod.getParameters(); int doubleSlotOffset = 0; for (int i = 0; i < para.length; i++) { ClassNode type = para[i].getType(); BytecodeHelper.load(mv, type, i + 1 + doubleSlotOffset); if (type.redirect() == ClassHelper.double_TYPE || type.redirect() == ClassHelper.long_TYPE) { doubleSlotOffset++; } if (!type.equals(goal[i].getType())) { BytecodeHelper.doCast(mv, goal[i].getType()); } } mv.visitMethodInsn(INVOKEVIRTUAL, BytecodeHelper.getClassInternalName(classNode), overridingMethod.getName(), BytecodeHelper.getMethodDescriptor( overridingMethod.getReturnType(), overridingMethod.getParameters()), false); BytecodeHelper.doReturn(mv, oldMethod.getReturnType()); } } ); newMethod.setCode(new BytecodeSequence(instructions)); return newMethod; } private boolean isAssignable(ClassNode node, ClassNode testNode) { if (node.isArray() && testNode.isArray()) { return isArrayAssignable(node.getComponentType(), testNode.getComponentType()); } if (testNode.isInterface()) { if (node.equals(testNode) || node.implementsInterface(testNode)) return true; } return node.isDerivedFrom(testNode); } private boolean isArrayAssignable(ClassNode node, ClassNode testNode) { if (node.isArray() && testNode.isArray()) { return isArrayAssignable(node.getComponentType(), testNode.getComponentType()); } return isAssignable(node, testNode); } private static Parameter[] cleanParameters(Parameter[] parameters) { Parameter[] params = new Parameter[parameters.length]; for (int i = 0; i < params.length; i++) { params[i] = new Parameter(cleanType(parameters[i].getType()), parameters[i].getName()); } return params; } private static ClassNode cleanType(ClassNode type) { // todo: should this be directly handled by getPlainNodeReference? if (type.isArray()) return cleanType(type.getComponentType()).makeArray(); return type.getPlainNodeReference(); } private void storeMissingCovariantMethods(Collection methods, MethodNode method, Map methodsToAdd, Map genericsSpec, boolean ignoreError) { for (Object next : methods) { MethodNode toOverride = (MethodNode) next; MethodNode bridgeMethod = getCovariantImplementation(toOverride, method, genericsSpec, ignoreError); if (bridgeMethod == null) continue; methodsToAdd.put(bridgeMethod.getTypeDescriptor(), bridgeMethod); return; } } private static boolean equalParametersNormal(MethodNode m1, MethodNode m2) { Parameter[] p1 = m1.getParameters(); Parameter[] p2 = m2.getParameters(); if (p1.length != p2.length) return false; for (int i = 0; i < p2.length; i++) { ClassNode type = p2[i].getType(); ClassNode parameterType = p1[i].getType(); if (!parameterType.equals(type)) return false; } return true; } private static boolean equalParametersWithGenerics(MethodNode m1, MethodNode m2, Map genericsSpec) { Parameter[] p1 = m1.getParameters(); Parameter[] p2 = m2.getParameters(); if (p1.length != p2.length) return false; for (int i = 0; i < p2.length; i++) { ClassNode type = p2[i].getType(); ClassNode genericsType = correctToGenericsSpec(genericsSpec, type); ClassNode parameterType = p1[i].getType(); if (!parameterType.equals(genericsType)) return false; } return true; } private static boolean moveOptimizedConstantsInitialization(final ClassNode node) { if (node.isInterface() && !Traits.isTrait(node)) return false; final int mods = ACC_STATIC | ACC_SYNTHETIC | ACC_PUBLIC; String name = SWAP_INIT; BlockStatement methodCode = new BlockStatement(); methodCode.addStatement(new SwapInitStatement()); boolean swapInitRequired = false; for (FieldNode fn : node.getFields()) { if (!fn.isStatic() || !fn.isSynthetic() || !fn.getName().startsWith("$const$")) continue; if (fn.getInitialExpression() == null) continue; final FieldExpression fe = new FieldExpression(fn); if (fn.getType().equals(ClassHelper.REFERENCE_TYPE)) fe.setUseReferenceDirectly(true); ConstantExpression init = (ConstantExpression) fn.getInitialExpression(); init = new ConstantExpression(init.getValue(), true); ExpressionStatement statement = new ExpressionStatement(new BinaryExpression(fe, Token.newSymbol(Types.EQUAL, fn.getLineNumber(), fn.getColumnNumber()), init)); fn.setInitialValueExpression(null); methodCode.addStatement(statement); swapInitRequired = true; } if (swapInitRequired) { node.addSyntheticMethod(name, mods, ClassHelper.VOID_TYPE, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, methodCode); } return swapInitRequired; } private static ASTNode sourceOf(MethodNode methodNode) { if (methodNode.getLineNumber() < 1) { ClassNode declaringClass = methodNode.getDeclaringClass(); if (methodNode.isSynthetic()) { String propertyName = getPropertyName(methodNode); if (propertyName != null) { PropertyNode propertyNode = declaringClass.getProperty(propertyName); if (propertyNode != null && propertyNode.getLineNumber() > 0) { return propertyNode; } } } return declaringClass; } return methodNode; } /** * When constant expressions are created, the value is always wrapped to a non primitive type. * Some constant expressions are optimized to return primitive types, but not all primitives are * handled. This method guarantees to return a similar constant expression but with a primitive type * instead of a boxed type. * <p/> * Additionally, single char strings are converted to 'char' types. * * @param constantExpression a constant expression * @return the same instance of constant expression if the type is already primitive, or a primitive * constant if possible. */ public static ConstantExpression transformToPrimitiveConstantIfPossible(ConstantExpression constantExpression) { Object value = constantExpression.getValue(); if (value == null) return constantExpression; ConstantExpression result; ClassNode type = constantExpression.getType(); if (ClassHelper.isPrimitiveType(type)) return constantExpression; if (value instanceof String && ((String) value).length() == 1) { result = new ConstantExpression(((String) value).charAt(0)); result.setType(ClassHelper.char_TYPE); } else { type = ClassHelper.getUnwrapper(type); result = new ConstantExpression(value, true); result.setType(type); } return result; } private static class SwapInitStatement extends BytecodeSequence { private WriterController controller; public SwapInitStatement() { super(new SwapInitInstruction()); ((SwapInitInstruction) getInstructions().get(0)).statement = this; } @Override public void visit(final GroovyCodeVisitor visitor) { if (visitor instanceof AsmClassGenerator) { AsmClassGenerator generator = (AsmClassGenerator) visitor; controller = generator.getController(); } super.visit(visitor); } private static class SwapInitInstruction extends BytecodeInstruction { SwapInitStatement statement; @Override public void visit(final MethodVisitor mv) { statement.controller.getCallSiteWriter().makeCallSiteArrayInitializer(); } } } }