Exemplo n.º 1
0
 private Expression convertInOperatorToTernary(
     final BinaryExpression bin,
     final Expression rightExpression,
     final Expression leftExpression) {
   MethodCallExpression call = new MethodCallExpression(rightExpression, "isCase", leftExpression);
   call.setMethodTarget(
       (MethodNode) bin.getNodeMetaData(StaticTypesMarker.DIRECT_METHOD_CALL_TARGET));
   call.setSourcePosition(bin);
   call.copyNodeMetaData(bin);
   TernaryExpression tExp =
       new TernaryExpression(
           new BooleanExpression(
               new BinaryExpression(
                   rightExpression, Token.newSymbol("==", -1, -1), new ConstantExpression(null))),
           new BinaryExpression(
               leftExpression, Token.newSymbol("==", -1, -1), new ConstantExpression(null)),
           call);
   return staticCompilationTransformer.transform(tExp);
 }
 private TernaryExpression createIfInstanceOfAsImmutableStatement(
     Expression expr, ClassNode type, Expression elseStatement) {
   return new TernaryExpression(
       new BooleanExpression(
           new BinaryExpression(
               expr,
               Token.newSymbol(Types.KEYWORD_INSTANCEOF, -1, -1),
               new ClassExpression(type))),
       createAsImmutableExpression(expr, type),
       elseStatement);
 }
Exemplo n.º 3
0
 public static ExpressionStatement createPrintlnStatement(String message, String variable) {
   return new ExpressionStatement(
       new MethodCallExpression(
           AbstractGrailsArtefactTransformer.THIS_EXPRESSION,
           "println",
           new ArgumentListExpression(
               new BinaryExpression(
                   new ConstantExpression(message),
                   Token.newSymbol(Types.PLUS, 0, 0),
                   new VariableExpression(variable)))));
 }
Exemplo n.º 4
0
  private IfStatement getAutowiringIfStatement(
      ClassExpression targetClass,
      VariableExpression fieldExpression,
      BinaryExpression testTargetAssignment) {
    VariableExpression appCtxVar = new VariableExpression("applicationContext");

    BooleanExpression applicationContextCheck =
        new BooleanExpression(
            new BinaryExpression(
                new BinaryExpression(
                    fieldExpression,
                    GrailsASTUtils.EQUALS_OPERATOR,
                    GrailsASTUtils.NULL_EXPRESSION),
                Token.newSymbol("&&", 0, 0),
                new BinaryExpression(
                    appCtxVar,
                    GrailsASTUtils.NOT_EQUALS_OPERATOR,
                    GrailsASTUtils.NULL_EXPRESSION)));
    BlockStatement performAutowireBlock = new BlockStatement();
    ArgumentListExpression arguments = new ArgumentListExpression();
    arguments.addExpression(fieldExpression);
    arguments.addExpression(new ConstantExpression(1));
    arguments.addExpression(new ConstantExpression(false));
    BlockStatement assignFromApplicationContext = new BlockStatement();
    ArgumentListExpression argWithClassName = new ArgumentListExpression();
    MethodCallExpression getClassNameMethodCall =
        new MethodCallExpression(targetClass, "getName", new ArgumentListExpression());
    argWithClassName.addExpression(getClassNameMethodCall);

    assignFromApplicationContext.addStatement(
        new ExpressionStatement(
            new BinaryExpression(
                fieldExpression,
                ASSIGN,
                new MethodCallExpression(appCtxVar, "getBean", argWithClassName))));
    BlockStatement elseBlock = new BlockStatement();
    elseBlock.addStatement(new ExpressionStatement(testTargetAssignment));
    performAutowireBlock.addStatement(
        new IfStatement(
            new BooleanExpression(
                new MethodCallExpression(appCtxVar, "containsBean", argWithClassName)),
            assignFromApplicationContext,
            elseBlock));
    performAutowireBlock.addStatement(
        new ExpressionStatement(
            new MethodCallExpression(
                new PropertyExpression(appCtxVar, "autowireCapableBeanFactory"),
                "autowireBeanProperties",
                arguments)));
    return new IfStatement(applicationContextCheck, performAutowireBlock, new BlockStatement());
  }
Exemplo n.º 5
0
 /**
  * Wraps a method body in try / catch logic that catches any errors and logs an error, but does
  * not rethrow!
  *
  * @param methodNode The method node
  */
 public static void wrapMethodBodyInTryCatchDebugStatements(MethodNode methodNode) {
   BlockStatement code = (BlockStatement) methodNode.getCode();
   BlockStatement newCode = new BlockStatement();
   TryCatchStatement tryCatchStatement = new TryCatchStatement(code, new BlockStatement());
   newCode.addStatement(tryCatchStatement);
   methodNode.setCode(newCode);
   BlockStatement catchBlock = new BlockStatement();
   ArgumentListExpression logArguments = new ArgumentListExpression();
   logArguments.addExpression(
       new BinaryExpression(
           new ConstantExpression("Error initializing class: "),
           Token.newSymbol(Types.PLUS, 0, 0),
           new VariableExpression("e")));
   logArguments.addExpression(new VariableExpression("e"));
   catchBlock.addStatement(
       new ExpressionStatement(
           new MethodCallExpression(new VariableExpression("log"), "error", logArguments)));
   tryCatchStatement.addCatch(
       new CatchStatement(new Parameter(new ClassNode(Throwable.class), "e"), catchBlock));
 }
  protected void addInitErrorsMethod(final ClassNode paramTypeClassNode) {
    final ASTNode initErrorsMethod =
        paramTypeClassNode.getMethod(
            INIT_ERRORS_METHOD_NAME, GrailsArtefactClassInjector.ZERO_PARAMETERS);
    if (initErrorsMethod == null) {
      final BlockStatement initErrorsMethodCode = new BlockStatement();

      final BinaryExpression errorsIsNullExpression =
          new BinaryExpression(
              ERRORS_EXPRESSION, Token.newSymbol(Types.COMPARE_EQUAL, 0, 0), NULL_EXPRESSION);

      Expression beanPropertyBindingResultConstructorArgs =
          new ArgumentListExpression(
              new VariableExpression("this"), new ConstantExpression(paramTypeClassNode.getName()));
      final Statement newEvaluatorExpression =
          new ExpressionStatement(
              new BinaryExpression(
                  ERRORS_EXPRESSION,
                  EQUALS_SYMBOL,
                  new ConstructorCallExpression(
                      new ClassNode(ValidationErrors.class),
                      beanPropertyBindingResultConstructorArgs)));
      final Statement initErrorsIfNullStatement =
          new IfStatement(
              new BooleanExpression(errorsIsNullExpression),
              newEvaluatorExpression,
              new ExpressionStatement(new EmptyExpression()));
      initErrorsMethodCode.addStatement(initErrorsIfNullStatement);
      paramTypeClassNode.addMethod(
          new MethodNode(
              INIT_ERRORS_METHOD_NAME,
              Modifier.PRIVATE,
              ClassHelper.VOID_TYPE,
              GrailsArtefactClassInjector.ZERO_PARAMETERS,
              GrailsArtefactClassInjector.EMPTY_CLASS_ARRAY,
              initErrorsMethodCode));
    }
  }
 Expression transformMethodCallExpression(final MethodCallExpression expr) {
   Expression objectExpression = expr.getObjectExpression();
   if (expr.isSafe()) {
     MethodCallExpression notSafe =
         new MethodCallExpression(objectExpression, expr.getMethod(), expr.getArguments());
     notSafe.copyNodeMetaData(expr);
     notSafe.setSpreadSafe(expr.isSpreadSafe());
     notSafe.setSourcePosition(expr);
     notSafe.setMethodTarget(expr.getMethodTarget());
     TernaryExpression texpr =
         new TernaryExpression(
             new BooleanExpression(
                 new BinaryExpression(
                     objectExpression,
                     Token.newSymbol(
                         "!=",
                         objectExpression.getLineNumber(),
                         objectExpression.getColumnNumber()),
                     ConstantExpression.NULL)),
             notSafe,
             ConstantExpression.NULL);
     return staticCompilationTransformer.transform(texpr);
   }
   ClassNode type =
       staticCompilationTransformer
           .getTypeChooser()
           .resolveType(objectExpression, staticCompilationTransformer.getClassNode());
   if (type != null && type.isArray()) {
     String method = expr.getMethodAsString();
     ClassNode componentType = type.getComponentType();
     if ("getAt".equals(method)) {
       Expression arguments = expr.getArguments();
       if (arguments instanceof TupleExpression) {
         List<Expression> argList = ((TupleExpression) arguments).getExpressions();
         if (argList.size() == 1) {
           Expression indexExpr = argList.get(0);
           ClassNode argType =
               staticCompilationTransformer
                   .getTypeChooser()
                   .resolveType(indexExpr, staticCompilationTransformer.getClassNode());
           ClassNode indexType = ClassHelper.getWrapper(argType);
           if (componentType.isEnum() && ClassHelper.Number_TYPE == indexType) {
             // workaround for generated code in enums which use .next() returning a Number
             indexType = ClassHelper.Integer_TYPE;
           }
           if (argType != null && ClassHelper.Integer_TYPE == indexType) {
             BinaryExpression binaryExpression =
                 new BinaryExpression(
                     objectExpression,
                     Token.newSymbol("[", indexExpr.getLineNumber(), indexExpr.getColumnNumber()),
                     indexExpr);
             binaryExpression.putNodeMetaData(StaticTypesMarker.INFERRED_TYPE, componentType);
             return staticCompilationTransformer.transform(binaryExpression);
           }
         }
       }
     }
     if ("putAt".equals(method)) {
       Expression arguments = expr.getArguments();
       if (arguments instanceof TupleExpression) {
         List<Expression> argList = ((TupleExpression) arguments).getExpressions();
         if (argList.size() == 2) {
           Expression indexExpr = argList.get(0);
           Expression objExpr = argList.get(1);
           ClassNode argType =
               staticCompilationTransformer
                   .getTypeChooser()
                   .resolveType(indexExpr, staticCompilationTransformer.getClassNode());
           if (argType != null && ClassHelper.Integer_TYPE == ClassHelper.getWrapper(argType)) {
             BinaryExpression arrayGet =
                 new BinaryExpression(
                     objectExpression,
                     Token.newSymbol("[", indexExpr.getLineNumber(), indexExpr.getColumnNumber()),
                     indexExpr);
             arrayGet.putNodeMetaData(StaticTypesMarker.INFERRED_TYPE, componentType);
             BinaryExpression assignment =
                 new BinaryExpression(
                     arrayGet,
                     Token.newSymbol("=", objExpr.getLineNumber(), objExpr.getColumnNumber()),
                     objExpr);
             return staticCompilationTransformer.transform(assignment);
           }
         }
       }
     }
   }
   return staticCompilationTransformer.superTransform(expr);
 }
Exemplo n.º 8
0
/**
 * Transformation used by the {@link grails.test.mixin.TestFor} annotation to signify the class
 * under test.
 *
 * @author Graeme Rocher
 * @since 2.0
 */
@GroovyASTTransformation(phase = CompilePhase.CANONICALIZATION)
@SuppressWarnings("rawtypes")
public class TestForTransformation extends TestMixinTransformation {

  private static final ClassNode MY_TYPE = new ClassNode(TestFor.class);
  private static final String MY_TYPE_NAME = "@" + MY_TYPE.getNameWithoutPackage();
  private static final Token ASSIGN = Token.newSymbol("=", -1, -1);

  protected static final Map<String, Class> artefactTypeToTestMap = new HashMap<String, Class>();

  static {
    artefactTypeToTestMap.put(ControllerArtefactHandler.TYPE, ControllerUnitTestMixin.class);
    artefactTypeToTestMap.put(TagLibArtefactHandler.TYPE, GroovyPageUnitTestMixin.class);
    artefactTypeToTestMap.put(
        FiltersConfigArtefactHandler.getTYPE().toString(), FiltersUnitTestMixin.class);
    artefactTypeToTestMap.put(UrlMappingsArtefactHandler.TYPE, UrlMappingsUnitTestMixin.class);
    artefactTypeToTestMap.put(ServiceArtefactHandler.TYPE, ServiceUnitTestMixin.class);
  }

  public static final String DOMAIN_TYPE = "Domain";
  public static final ClassNode BEFORE_CLASS_NODE = new ClassNode(Before.class);
  public static final AnnotationNode BEFORE_ANNOTATION = new AnnotationNode(BEFORE_CLASS_NODE);

  public static final AnnotationNode TEST_ANNOTATION =
      new AnnotationNode(new ClassNode(Test.class));
  public static final ClassNode GROOVY_TEST_CASE_CLASS = new ClassNode(GroovyTestCase.class);

  private ResourceLocator resourceLocator;

  public ResourceLocator getResourceLocator() {
    if (resourceLocator == null) {
      resourceLocator = new DefaultResourceLocator();
      BuildSettings buildSettings = BuildSettingsHolder.getSettings();
      String basedir;
      if (buildSettings != null) {
        basedir = buildSettings.getBaseDir().getAbsolutePath();
      } else {
        basedir = ".";
      }

      resourceLocator.setSearchLocation(basedir);
    }
    return resourceLocator;
  }

  @Override
  public void visit(ASTNode[] astNodes, SourceUnit source) {
    if (!(astNodes[0] instanceof AnnotationNode) || !(astNodes[1] instanceof AnnotatedNode)) {
      throw new RuntimeException("Internal error: wrong types: $node.class / $parent.class");
    }

    AnnotatedNode parent = (AnnotatedNode) astNodes[1];
    AnnotationNode node = (AnnotationNode) astNodes[0];
    if (!MY_TYPE.equals(node.getClassNode()) || !(parent instanceof ClassNode)) {
      return;
    }

    ClassNode classNode = (ClassNode) parent;
    if (classNode.isInterface() || Modifier.isAbstract(classNode.getModifiers())) {
      return;
    }

    boolean junit3Test = isJunit3Test(classNode);
    boolean spockTest = isSpockTest(classNode);
    boolean isJunit = classNode.getName().endsWith("Tests");

    if (!junit3Test && !spockTest && !isJunit) return;

    Expression value = node.getMember("value");
    ClassExpression ce;
    if (value instanceof ClassExpression) {
      ce = (ClassExpression) value;
      testFor(classNode, ce);
    } else {
      if (!junit3Test) {
        List<AnnotationNode> annotations = classNode.getAnnotations(MY_TYPE);
        if (annotations.size() > 0)
          return; // bail out, in this case it was already applied as a local transform
        // no explicit class specified try by convention
        String fileName = source.getName();
        String className = GrailsResourceUtils.getClassName(new FileSystemResource(fileName));
        if (className != null) {
          boolean isSpock = className.endsWith("Spec");
          String targetClassName = null;

          if (isJunit) {
            targetClassName = className.substring(0, className.indexOf("Tests"));
          } else if (isSpock) {
            targetClassName = className.substring(0, className.indexOf("Spec"));
          }

          if (targetClassName != null) {
            Resource targetResource =
                getResourceLocator().findResourceForClassName(targetClassName);
            if (targetResource != null) {
              try {
                if (GrailsResourceUtils.isDomainClass(targetResource.getURL())) {
                  testFor(
                      classNode,
                      new ClassExpression(
                          new ClassNode(targetClassName, 0, ClassHelper.OBJECT_TYPE)));
                } else {
                  for (String artefactType : artefactTypeToTestMap.keySet()) {
                    if (targetClassName.endsWith(artefactType)) {
                      testFor(
                          classNode,
                          new ClassExpression(
                              new ClassNode(targetClassName, 0, ClassHelper.OBJECT_TYPE)));
                      break;
                    }
                  }
                }
              } catch (IOException e) {
                // ignore
              }
            }
          }
        }
      }
    }
  }

  /**
   * Main entry point for the calling the TestForTransformation programmatically.
   *
   * @param classNode The class node that represents th test
   * @param ce The class expression that represents the class to test
   */
  public void testFor(ClassNode classNode, ClassExpression ce) {
    boolean junit3Test = isJunit3Test(classNode);

    // make sure the 'log' property is not the one from GroovyTestCase
    FieldNode log = classNode.getField("log");
    if (log == null || log.getDeclaringClass().equals(GROOVY_TEST_CASE_CLASS)) {
      LoggingTransformer.addLogField(classNode, classNode.getName());
    }
    boolean isSpockTest = isSpockTest(classNode);

    if (!isSpockTest && !junit3Test) {
      // assume JUnit 4
      Map<String, MethodNode> declaredMethodsMap = classNode.getDeclaredMethodsMap();
      for (String methodName : declaredMethodsMap.keySet()) {
        MethodNode methodNode = declaredMethodsMap.get(methodName);
        if (isCandidateMethod(methodNode) && methodNode.getName().startsWith("test")) {
          if (methodNode.getAnnotations().size() == 0) {
            methodNode.addAnnotation(TEST_ANNOTATION);
          }
        }
      }
    }

    final MethodNode methodToAdd = weaveMock(classNode, ce, true);
    if (methodToAdd != null && junit3Test) {
      addMethodCallsToMethod(classNode, SET_UP_METHOD, Arrays.asList(methodToAdd));
    }
  }

  private Map<ClassNode, List<Class>> wovenMixins = new HashMap<ClassNode, List<Class>>();

  protected MethodNode weaveMock(
      ClassNode classNode, ClassExpression value, boolean isClassUnderTest) {

    ClassNode testTarget = value.getType();
    String className = testTarget.getName();
    MethodNode testForMethod = null;
    for (String artefactType : artefactTypeToTestMap.keySet()) {
      if (className.endsWith(artefactType)) {
        Class mixinClass = artefactTypeToTestMap.get(artefactType);
        if (!isAlreadyWoven(classNode, mixinClass)) {
          weaveMixinClass(classNode, mixinClass);
          if (isClassUnderTest) {
            testForMethod = addClassUnderTestMethod(classNode, value, artefactType);
          } else {
            addMockCollaboratorToSetup(classNode, value, artefactType);
          }
          return testForMethod;
        }

        addMockCollaboratorToSetup(classNode, value, artefactType);
        return null;
      }
    }

    // must be a domain class
    weaveMixinClass(classNode, DomainClassUnitTestMixin.class);
    if (isClassUnderTest) {
      testForMethod = addClassUnderTestMethod(classNode, value, DOMAIN_TYPE);
    } else {
      addMockCollaboratorToSetup(classNode, value, DOMAIN_TYPE);
    }

    return testForMethod;
  }

  private void addMockCollaboratorToSetup(
      ClassNode classNode, ClassExpression targetClassExpression, String artefactType) {

    BlockStatement methodBody;
    if (isJunit3Test(classNode)) {
      methodBody = getJunit3Setup(classNode);
      addMockCollaborator(artefactType, targetClassExpression, methodBody);
    } else {
      addToJunit4BeforeMethods(classNode, artefactType, targetClassExpression);
    }
  }

  private void addToJunit4BeforeMethods(
      ClassNode classNode, String artefactType, ClassExpression targetClassExpression) {
    Map<String, MethodNode> declaredMethodsMap = classNode.getDeclaredMethodsMap();
    boolean weavedIntoBeforeMethods = false;
    for (MethodNode methodNode : declaredMethodsMap.values()) {
      if (isDeclaredBeforeMethod(methodNode)) {
        Statement code = getMethodBody(methodNode);
        addMockCollaborator(artefactType, targetClassExpression, (BlockStatement) code);
        weavedIntoBeforeMethods = true;
      }
    }

    if (!weavedIntoBeforeMethods) {
      BlockStatement junit4Setup = getJunit4Setup(classNode);
      addMockCollaborator(artefactType, targetClassExpression, junit4Setup);
    }
  }

  private Statement getMethodBody(MethodNode methodNode) {
    Statement code = methodNode.getCode();
    if (!(code instanceof BlockStatement)) {
      BlockStatement body = new BlockStatement();
      body.addStatement(code);
      code = body;
    }
    return code;
  }

  private boolean isDeclaredBeforeMethod(MethodNode methodNode) {
    return isPublicInstanceMethod(methodNode)
        && hasAnnotation(methodNode, Before.class)
        && !hasAnnotation(methodNode, MixinMethod.class);
  }

  private boolean isPublicInstanceMethod(MethodNode methodNode) {
    return !methodNode.isSynthetic() && !methodNode.isStatic() && methodNode.isPublic();
  }

  private BlockStatement getJunit4Setup(ClassNode classNode) {
    MethodNode setupMethod =
        classNode.getMethod(SET_UP_METHOD, GrailsArtefactClassInjector.ZERO_PARAMETERS);
    if (setupMethod == null) {
      setupMethod =
          new MethodNode(
              SET_UP_METHOD,
              Modifier.PUBLIC,
              ClassHelper.VOID_TYPE,
              GrailsArtefactClassInjector.ZERO_PARAMETERS,
              null,
              new BlockStatement());
      setupMethod.addAnnotation(MIXIN_METHOD_ANNOTATION);
      classNode.addMethod(setupMethod);
    }
    if (setupMethod.getAnnotations(BEFORE_CLASS_NODE).size() == 0) {
      setupMethod.addAnnotation(BEFORE_ANNOTATION);
    }
    return getOrCreateMethodBody(classNode, setupMethod, SET_UP_METHOD);
  }

  private BlockStatement getJunit3Setup(ClassNode classNode) {
    return getOrCreateNoArgsMethodBody(classNode, SET_UP_METHOD);
  }

  private boolean isAlreadyWoven(ClassNode classNode, Class mixinClass) {
    List<Class> mixinClasses = wovenMixins.get(classNode);
    if (mixinClasses == null) {
      mixinClasses = new ArrayList<Class>();
      mixinClasses.add(mixinClass);
      wovenMixins.put(classNode, mixinClasses);
    } else {
      if (mixinClasses.contains(mixinClass)) {
        return true;
      }

      mixinClasses.add(mixinClass);
    }
    return false;
  }

  protected void weaveMixinClass(ClassNode classNode, Class mixinClass) {
    ListExpression listExpression = new ListExpression();
    listExpression.addExpression(new ClassExpression(new ClassNode(mixinClass)));
    weaveMixinsIntoClass(classNode, listExpression);
  }

  protected MethodNode addClassUnderTestMethod(
      ClassNode classNode, ClassExpression targetClass, String type) {

    String methodName = "setup" + type + "UnderTest";
    String fieldName = GrailsNameUtils.getPropertyName(type);
    String getterName = GrailsNameUtils.getGetterName(fieldName);
    fieldName = '$' + fieldName;

    if (classNode.getField(fieldName) == null) {
      classNode.addField(fieldName, Modifier.PRIVATE, targetClass.getType(), null);
    }

    MethodNode methodNode =
        classNode.getMethod(methodName, GrailsArtefactClassInjector.ZERO_PARAMETERS);

    VariableExpression fieldExpression = new VariableExpression(fieldName);
    if (methodNode == null) {
      BlockStatement setupMethodBody = new BlockStatement();
      addMockCollaborator(type, targetClass, setupMethodBody);

      methodNode =
          new MethodNode(
              methodName,
              Modifier.PUBLIC,
              ClassHelper.VOID_TYPE,
              GrailsArtefactClassInjector.ZERO_PARAMETERS,
              null,
              setupMethodBody);
      methodNode.addAnnotation(BEFORE_ANNOTATION);
      methodNode.addAnnotation(MIXIN_METHOD_ANNOTATION);
      classNode.addMethod(methodNode);
    }

    MethodNode getter =
        classNode.getMethod(getterName, GrailsArtefactClassInjector.ZERO_PARAMETERS);
    if (getter == null) {
      BlockStatement getterBody = new BlockStatement();
      getter =
          new MethodNode(
              getterName,
              Modifier.PUBLIC,
              targetClass.getType().getPlainNodeReference(),
              GrailsArtefactClassInjector.ZERO_PARAMETERS,
              null,
              getterBody);

      BinaryExpression testTargetAssignment =
          new BinaryExpression(
              fieldExpression,
              ASSIGN,
              new ConstructorCallExpression(
                  targetClass.getType(), GrailsArtefactClassInjector.ZERO_ARGS));

      IfStatement autowiringIfStatement =
          getAutowiringIfStatement(targetClass, fieldExpression, testTargetAssignment);
      getterBody.addStatement(autowiringIfStatement);

      getterBody.addStatement(new ReturnStatement(fieldExpression));
      classNode.addMethod(getter);
    }

    return methodNode;
  }

  private IfStatement getAutowiringIfStatement(
      ClassExpression targetClass,
      VariableExpression fieldExpression,
      BinaryExpression testTargetAssignment) {
    VariableExpression appCtxVar = new VariableExpression("applicationContext");

    BooleanExpression applicationContextCheck =
        new BooleanExpression(
            new BinaryExpression(
                new BinaryExpression(
                    fieldExpression,
                    GrailsASTUtils.EQUALS_OPERATOR,
                    GrailsASTUtils.NULL_EXPRESSION),
                Token.newSymbol("&&", 0, 0),
                new BinaryExpression(
                    appCtxVar,
                    GrailsASTUtils.NOT_EQUALS_OPERATOR,
                    GrailsASTUtils.NULL_EXPRESSION)));
    BlockStatement performAutowireBlock = new BlockStatement();
    ArgumentListExpression arguments = new ArgumentListExpression();
    arguments.addExpression(fieldExpression);
    arguments.addExpression(new ConstantExpression(1));
    arguments.addExpression(new ConstantExpression(false));
    BlockStatement assignFromApplicationContext = new BlockStatement();
    ArgumentListExpression argWithClassName = new ArgumentListExpression();
    MethodCallExpression getClassNameMethodCall =
        new MethodCallExpression(targetClass, "getName", new ArgumentListExpression());
    argWithClassName.addExpression(getClassNameMethodCall);

    assignFromApplicationContext.addStatement(
        new ExpressionStatement(
            new BinaryExpression(
                fieldExpression,
                ASSIGN,
                new MethodCallExpression(appCtxVar, "getBean", argWithClassName))));
    BlockStatement elseBlock = new BlockStatement();
    elseBlock.addStatement(new ExpressionStatement(testTargetAssignment));
    performAutowireBlock.addStatement(
        new IfStatement(
            new BooleanExpression(
                new MethodCallExpression(appCtxVar, "containsBean", argWithClassName)),
            assignFromApplicationContext,
            elseBlock));
    performAutowireBlock.addStatement(
        new ExpressionStatement(
            new MethodCallExpression(
                new PropertyExpression(appCtxVar, "autowireCapableBeanFactory"),
                "autowireBeanProperties",
                arguments)));
    return new IfStatement(applicationContextCheck, performAutowireBlock, new BlockStatement());
  }

  protected void addMockCollaborator(
      String mockType, ClassExpression targetClass, BlockStatement methodBody) {
    ArgumentListExpression args = new ArgumentListExpression();
    args.addExpression(targetClass);
    methodBody
        .getStatements()
        .add(
            0,
            new ExpressionStatement(
                new MethodCallExpression(THIS_EXPRESSION, "mock" + mockType, args)));
  }
}
/** @author Jeff Brown */
public class ASTValidationErrorsHelper implements ASTErrorsHelper {
  private static final ConstantExpression NULL_EXPRESSION = new ConstantExpression(null);
  private static final String SET_ERRORS_METHOD_NAME = "setErrors";
  private static final String GET_ERRORS_METHOD_NAME = "getErrors";
  private static final String HAS_ERRORS_METHOD_NAME = "hasErrors";
  private static final String CLEAR_ERRORS_METHOD_NAME = "clearErrors";
  private static final String INIT_ERRORS_METHOD_NAME = "initErrors";
  private static final String ERRORS_PROPERTY_NAME = "errors";
  private static final Token EQUALS_SYMBOL = Token.newSymbol(Types.EQUALS, 0, 0);
  private static final ClassNode ERRORS_CLASS_NODE = new ClassNode(Errors.class);
  private static final VariableExpression ERRORS_EXPRESSION =
      new VariableExpression(ERRORS_PROPERTY_NAME);
  private static final TupleExpression EMPTY_TUPLE = new TupleExpression();

  public void injectErrorsCode(ClassNode classNode) {
    addErrorsField(classNode);
    addInitErrorsMethod(classNode);
    addGetErrorsMethod(classNode);
    addHasErrorsMethod(classNode);
    addSetErrorsMethod(classNode);
    addClearErrorsMethod(classNode);
  }

  protected void addErrorsField(final ClassNode paramTypeClassNode) {
    final ASTNode errorsField = paramTypeClassNode.getField(ERRORS_PROPERTY_NAME);
    if (errorsField == null) {
      paramTypeClassNode.addField(
          new FieldNode(
              ERRORS_PROPERTY_NAME,
              Modifier.PRIVATE,
              ERRORS_CLASS_NODE,
              paramTypeClassNode,
              NULL_EXPRESSION));
    }
  }

  protected void addInitErrorsMethod(final ClassNode paramTypeClassNode) {
    final ASTNode initErrorsMethod =
        paramTypeClassNode.getMethod(
            INIT_ERRORS_METHOD_NAME, GrailsArtefactClassInjector.ZERO_PARAMETERS);
    if (initErrorsMethod == null) {
      final BlockStatement initErrorsMethodCode = new BlockStatement();

      final BinaryExpression errorsIsNullExpression =
          new BinaryExpression(
              ERRORS_EXPRESSION, Token.newSymbol(Types.COMPARE_EQUAL, 0, 0), NULL_EXPRESSION);

      Expression beanPropertyBindingResultConstructorArgs =
          new ArgumentListExpression(
              new VariableExpression("this"), new ConstantExpression(paramTypeClassNode.getName()));
      final Statement newEvaluatorExpression =
          new ExpressionStatement(
              new BinaryExpression(
                  ERRORS_EXPRESSION,
                  EQUALS_SYMBOL,
                  new ConstructorCallExpression(
                      new ClassNode(ValidationErrors.class),
                      beanPropertyBindingResultConstructorArgs)));
      final Statement initErrorsIfNullStatement =
          new IfStatement(
              new BooleanExpression(errorsIsNullExpression),
              newEvaluatorExpression,
              new ExpressionStatement(new EmptyExpression()));
      initErrorsMethodCode.addStatement(initErrorsIfNullStatement);
      paramTypeClassNode.addMethod(
          new MethodNode(
              INIT_ERRORS_METHOD_NAME,
              Modifier.PRIVATE,
              ClassHelper.VOID_TYPE,
              GrailsArtefactClassInjector.ZERO_PARAMETERS,
              GrailsArtefactClassInjector.EMPTY_CLASS_ARRAY,
              initErrorsMethodCode));
    }
  }

  protected void addClearErrorsMethod(final ClassNode paramTypeClassNode) {
    final ASTNode clearErrorsMethod =
        paramTypeClassNode.getMethod(
            CLEAR_ERRORS_METHOD_NAME, GrailsArtefactClassInjector.ZERO_PARAMETERS);
    if (clearErrorsMethod == null) {
      final BlockStatement clearErrorsMethodCode = new BlockStatement();
      Expression nullOutErrorsFieldExpression =
          new BinaryExpression(ERRORS_EXPRESSION, EQUALS_SYMBOL, NULL_EXPRESSION);
      clearErrorsMethodCode.addStatement(new ExpressionStatement(nullOutErrorsFieldExpression));
      paramTypeClassNode.addMethod(
          new MethodNode(
              CLEAR_ERRORS_METHOD_NAME,
              Modifier.PUBLIC,
              ClassHelper.VOID_TYPE,
              GrailsArtefactClassInjector.ZERO_PARAMETERS,
              GrailsArtefactClassInjector.EMPTY_CLASS_ARRAY,
              clearErrorsMethodCode));
    }
  }

  protected void addHasErrorsMethod(final ClassNode paramTypeClassNode) {
    final ASTNode getErrorsMethod =
        paramTypeClassNode.getMethod(
            HAS_ERRORS_METHOD_NAME, GrailsArtefactClassInjector.ZERO_PARAMETERS);
    if (getErrorsMethod == null) {
      final BlockStatement hasErrorsMethodCode = new BlockStatement();
      final Expression initErrorsMethodCallExpression =
          new MethodCallExpression(
              new VariableExpression("this"), INIT_ERRORS_METHOD_NAME, EMPTY_TUPLE);
      hasErrorsMethodCode.addStatement(new ExpressionStatement(initErrorsMethodCallExpression));
      final Statement returnStatement =
          new ReturnStatement(
              new BooleanExpression(
                  new MethodCallExpression(
                      ERRORS_EXPRESSION, HAS_ERRORS_METHOD_NAME, EMPTY_TUPLE)));
      hasErrorsMethodCode.addStatement(returnStatement);
      paramTypeClassNode.addMethod(
          new MethodNode(
              HAS_ERRORS_METHOD_NAME,
              Modifier.PUBLIC,
              new ClassNode(Boolean.class),
              GrailsArtefactClassInjector.ZERO_PARAMETERS,
              GrailsArtefactClassInjector.EMPTY_CLASS_ARRAY,
              hasErrorsMethodCode));
    }
  }

  protected void addGetErrorsMethod(final ClassNode paramTypeClassNode) {
    final ASTNode getErrorsMethod =
        paramTypeClassNode.getMethod(
            GET_ERRORS_METHOD_NAME, GrailsArtefactClassInjector.ZERO_PARAMETERS);
    if (getErrorsMethod == null) {
      final BlockStatement getErrorsMethodCode = new BlockStatement();
      final Expression initErrorsMethodCallExpression =
          new MethodCallExpression(
              new VariableExpression("this"), INIT_ERRORS_METHOD_NAME, EMPTY_TUPLE);
      getErrorsMethodCode.addStatement(new ExpressionStatement(initErrorsMethodCallExpression));
      final Statement returnStatement = new ReturnStatement(ERRORS_EXPRESSION);
      getErrorsMethodCode.addStatement(returnStatement);
      paramTypeClassNode.addMethod(
          new MethodNode(
              GET_ERRORS_METHOD_NAME,
              Modifier.PUBLIC,
              ERRORS_CLASS_NODE,
              GrailsArtefactClassInjector.ZERO_PARAMETERS,
              GrailsArtefactClassInjector.EMPTY_CLASS_ARRAY,
              getErrorsMethodCode));
    }
  }

  protected void addSetErrorsMethod(final ClassNode paramTypeClassNode) {
    final String errorsArgumentName = "$errorsArg";
    MethodNode setErrorsMethod =
        paramTypeClassNode.getMethod(
            SET_ERRORS_METHOD_NAME,
            new Parameter[] {new Parameter(ERRORS_CLASS_NODE, errorsArgumentName)});
    if (setErrorsMethod == null) {
      final Expression assignErrorsExpression =
          new BinaryExpression(
              ERRORS_EXPRESSION, EQUALS_SYMBOL, new VariableExpression(errorsArgumentName));
      setErrorsMethod =
          new MethodNode(
              SET_ERRORS_METHOD_NAME,
              Modifier.PUBLIC,
              ClassHelper.VOID_TYPE,
              new Parameter[] {new Parameter(ERRORS_CLASS_NODE, errorsArgumentName)},
              GrailsArtefactClassInjector.EMPTY_CLASS_ARRAY,
              new ExpressionStatement(assignErrorsExpression));
      paramTypeClassNode.addMethod(setErrorsMethod);
    }
  }
}
Exemplo n.º 10
0
/**
 * Helper methods for working with Groovy AST trees.
 *
 * @author Graeme Rocher
 * @since 0.3
 */
public class GrailsASTUtils {

  public static final String METHOD_MISSING_METHOD_NAME = "methodMissing";
  public static final String STATIC_METHOD_MISSING_METHOD_NAME = "$static_methodMissing";
  public static final Token EQUALS_OPERATOR = Token.newSymbol("==", 0, 0);
  public static final Token NOT_EQUALS_OPERATOR = Token.newSymbol("!=", 0, 0);

  public static final ClassNode MISSING_METHOD_EXCEPTION =
      new ClassNode(MissingMethodException.class);
  public static final ConstantExpression NULL_EXPRESSION = new ConstantExpression(null);
  public static final Token ASSIGNMENT_OPERATOR = Token.newSymbol(Types.ASSIGNMENT_OPERATOR, 0, 0);

  public static void warning(
      final SourceUnit sourceUnit, final ASTNode node, final String warningMessage) {
    final String sample =
        sourceUnit.getSample(node.getLineNumber(), node.getColumnNumber(), new Janitor());
    GrailsConsole.getInstance().warning(warningMessage + "\n\n" + sample);
  }

  /**
   * Generates a fatal compilation error
   *
   * @param sourceUnit the SourceUnit
   * @param astNode the ASTNode which caused the error
   * @param message The error message
   */
  public static void error(
      final SourceUnit sourceUnit, final ASTNode astNode, final String message) {
    error(sourceUnit, astNode, message, true);
  }

  /**
   * Generates a fatal compilation error
   *
   * @param sourceUnit the SourceUnit
   * @param astNode the ASTNode which caused the error
   * @param message The error message
   * @param fatal indicates if this is a fatal error
   */
  public static void error(
      final SourceUnit sourceUnit,
      final ASTNode astNode,
      final String message,
      final boolean fatal) {
    final SyntaxException syntaxException =
        new SyntaxException(message, astNode.getLineNumber(), astNode.getColumnNumber());
    final SyntaxErrorMessage syntaxErrorMessage =
        new SyntaxErrorMessage(syntaxException, sourceUnit);
    sourceUnit.getErrorCollector().addError(syntaxErrorMessage, fatal);
  }

  /**
   * Returns whether a classNode has the specified property or not
   *
   * @param classNode The ClassNode
   * @param propertyName The name of the property
   * @return True if the property exists in the ClassNode
   */
  public static boolean hasProperty(ClassNode classNode, String propertyName) {
    if (classNode == null || StringUtils.isBlank(propertyName)) {
      return false;
    }

    final MethodNode method =
        classNode.getMethod(GrailsNameUtils.getGetterName(propertyName), Parameter.EMPTY_ARRAY);
    if (method != null) return true;

    for (PropertyNode pn : classNode.getProperties()) {
      if (pn.getName().equals(propertyName) && !pn.isPrivate()) {
        return true;
      }
    }

    return false;
  }

  public static boolean hasOrInheritsProperty(ClassNode classNode, String propertyName) {
    if (hasProperty(classNode, propertyName)) {
      return true;
    }

    ClassNode parent = classNode.getSuperClass();
    while (parent != null && !getFullName(parent).equals("java.lang.Object")) {
      if (hasProperty(parent, propertyName)) {
        return true;
      }
      parent = parent.getSuperClass();
    }

    return false;
  }

  /**
   * Tests whether the ClasNode implements the specified method name.
   *
   * @param classNode The ClassNode
   * @param methodName The method name
   * @return True if it does implement the method
   */
  public static boolean implementsZeroArgMethod(ClassNode classNode, String methodName) {
    MethodNode method = classNode.getDeclaredMethod(methodName, Parameter.EMPTY_ARRAY);
    return method != null && (method.isPublic() || method.isProtected()) && !method.isAbstract();
  }

  @SuppressWarnings("rawtypes")
  public static boolean implementsOrInheritsZeroArgMethod(
      ClassNode classNode, String methodName, List ignoreClasses) {
    if (implementsZeroArgMethod(classNode, methodName)) {
      return true;
    }

    ClassNode parent = classNode.getSuperClass();
    while (parent != null && !getFullName(parent).equals("java.lang.Object")) {
      if (!ignoreClasses.contains(parent) && implementsZeroArgMethod(parent, methodName)) {
        return true;
      }
      parent = parent.getSuperClass();
    }
    return false;
  }

  /**
   * Gets the full name of a ClassNode.
   *
   * @param classNode The class node
   * @return The full name
   */
  public static String getFullName(ClassNode classNode) {
    return classNode.getName();
  }

  public static ClassNode getFurthestParent(ClassNode classNode) {
    ClassNode parent = classNode.getSuperClass();
    while (parent != null && !getFullName(parent).equals("java.lang.Object")) {
      classNode = parent;
      parent = parent.getSuperClass();
    }
    return classNode;
  }

  public static ClassNode getFurthestUnresolvedParent(ClassNode classNode) {
    ClassNode parent = classNode.getSuperClass();

    while (parent != null
        && !getFullName(parent).equals("java.lang.Object")
        && !parent.isResolved()
        && !Modifier.isAbstract(parent.getModifiers())) {
      classNode = parent;
      parent = parent.getSuperClass();
    }
    return classNode;
  }

  /**
   * Adds a delegate method to the target class node where the first argument is to the delegate
   * method is 'this'. In other words a method such as foo(Object instance, String bar) would be
   * added with a signature of foo(String) and 'this' is passed to the delegate instance
   *
   * @param classNode The class node
   * @param delegate The expression that looks up the delegate
   * @param declaredMethod The declared method
   * @return The added method node or null if it couldn't be added
   */
  public static MethodNode addDelegateInstanceMethod(
      ClassNode classNode, Expression delegate, MethodNode declaredMethod) {
    return addDelegateInstanceMethod(classNode, delegate, declaredMethod, true);
  }

  /**
   * Adds a delegate method to the target class node where the first argument is to the delegate
   * method is 'this'. In other words a method such as foo(Object instance, String bar) would be
   * added with a signature of foo(String) and 'this' is passed to the delegate instance
   *
   * @param classNode The class node
   * @param delegate The expression that looks up the delegate
   * @param declaredMethod The declared method
   * @param thisAsFirstArgument Whether 'this' should be passed as the first argument to the method
   * @return The added method node or null if it couldn't be added
   */
  public static MethodNode addDelegateInstanceMethod(
      ClassNode classNode,
      Expression delegate,
      MethodNode declaredMethod,
      boolean thisAsFirstArgument) {
    Parameter[] parameterTypes =
        thisAsFirstArgument
            ? getRemainingParameterTypes(declaredMethod.getParameters())
            : declaredMethod.getParameters();
    String methodName = declaredMethod.getName();
    if (classNode.hasDeclaredMethod(methodName, parameterTypes)) {
      return null;
    }
    String propertyName = GrailsClassUtils.getPropertyForGetter(methodName);
    if (propertyName != null && parameterTypes.length == 0 && classNode.hasProperty(propertyName)) {
      return null;
    }
    propertyName = GrailsClassUtils.getPropertyForSetter(methodName);
    if (propertyName != null && parameterTypes.length == 1 && classNode.hasProperty(propertyName)) {
      return null;
    }

    BlockStatement methodBody = new BlockStatement();
    ArgumentListExpression arguments =
        createArgumentListFromParameters(parameterTypes, thisAsFirstArgument);

    ClassNode returnType = nonGeneric(declaredMethod.getReturnType());

    MethodCallExpression methodCallExpression =
        new MethodCallExpression(delegate, methodName, arguments);
    methodCallExpression.setMethodTarget(declaredMethod);
    ThrowStatement missingMethodException = createMissingMethodThrowable(classNode, declaredMethod);
    VariableExpression apiVar = addApiVariableDeclaration(delegate, declaredMethod, methodBody);
    IfStatement ifStatement =
        createIfElseStatementForApiMethodCall(methodCallExpression, apiVar, missingMethodException);

    methodBody.addStatement(ifStatement);
    MethodNode methodNode =
        new MethodNode(
            methodName,
            Modifier.PUBLIC,
            returnType,
            copyParameters(parameterTypes),
            GrailsArtefactClassInjector.EMPTY_CLASS_ARRAY,
            methodBody);
    methodNode.addAnnotations(declaredMethod.getAnnotations());

    classNode.addMethod(methodNode);
    return methodNode;
  }

  private static IfStatement createIfElseStatementForApiMethodCall(
      MethodCallExpression methodCallExpression,
      VariableExpression apiVar,
      ThrowStatement missingMethodException) {
    BlockStatement ifBlock = new BlockStatement();
    ifBlock.addStatement(missingMethodException);
    BlockStatement elseBlock = new BlockStatement();
    elseBlock.addStatement(new ExpressionStatement(methodCallExpression));

    return new IfStatement(
        new BooleanExpression(new BinaryExpression(apiVar, EQUALS_OPERATOR, NULL_EXPRESSION)),
        ifBlock,
        elseBlock);
  }

  private static VariableExpression addApiVariableDeclaration(
      Expression delegate, MethodNode declaredMethod, BlockStatement methodBody) {
    VariableExpression apiVar = new VariableExpression("$api_" + declaredMethod.getName());
    DeclarationExpression de = new DeclarationExpression(apiVar, ASSIGNMENT_OPERATOR, delegate);
    methodBody.addStatement(new ExpressionStatement(de));
    return apiVar;
  }

  private static ThrowStatement createMissingMethodThrowable(
      ClassNode classNode, MethodNode declaredMethodNode) {
    ArgumentListExpression exceptionArgs = new ArgumentListExpression();
    exceptionArgs.addExpression(new ConstantExpression(declaredMethodNode.getName()));
    exceptionArgs.addExpression(new ClassExpression(classNode));
    return new ThrowStatement(
        new ConstructorCallExpression(MISSING_METHOD_EXCEPTION, exceptionArgs));
  }

  /**
   * Creates an argument list from the given parameter types.
   *
   * @param parameterTypes The parameter types
   * @param thisAsFirstArgument Whether to include a reference to 'this' as the first argument
   * @return the arguments
   */
  public static ArgumentListExpression createArgumentListFromParameters(
      Parameter[] parameterTypes, boolean thisAsFirstArgument) {
    ArgumentListExpression arguments = new ArgumentListExpression();

    if (thisAsFirstArgument) {
      arguments.addExpression(AbstractGrailsArtefactTransformer.THIS_EXPRESSION);
    }

    for (Parameter parameterType : parameterTypes) {
      arguments.addExpression(new VariableExpression(parameterType.getName()));
    }
    return arguments;
  }

  /**
   * Gets the remaining parameters excluding the first parameter in the given list
   *
   * @param parameters The parameters
   * @return A new array with the first parameter removed
   */
  public static Parameter[] getRemainingParameterTypes(Parameter[] parameters) {
    if (parameters.length == 0) {
      return GrailsArtefactClassInjector.ZERO_PARAMETERS;
    }

    Parameter[] newParameters = new Parameter[parameters.length - 1];
    System.arraycopy(parameters, 1, newParameters, 0, parameters.length - 1);
    return newParameters;
  }

  /**
   * Adds a static method call to given class node that delegates to the given method
   *
   * @param classNode The class node
   * @param delegateMethod The delegate method
   * @return The added method node or null if it couldn't be added
   */
  public static MethodNode addDelegateStaticMethod(ClassNode classNode, MethodNode delegateMethod) {
    ClassExpression classExpression = new ClassExpression(delegateMethod.getDeclaringClass());
    return addDelegateStaticMethod(classExpression, classNode, delegateMethod);
  }

  /**
   * Adds a static method to the given class node that delegates to the given method and resolves
   * the object to invoke the method on from the given expression.
   *
   * @param expression The expression
   * @param classNode The class node
   * @param delegateMethod The delegate method
   * @return The added method node or null if it couldn't be added
   */
  public static MethodNode addDelegateStaticMethod(
      Expression expression, ClassNode classNode, MethodNode delegateMethod) {
    Parameter[] parameterTypes = delegateMethod.getParameters();
    String declaredMethodName = delegateMethod.getName();
    if (classNode.hasDeclaredMethod(declaredMethodName, parameterTypes)) {
      return null;
    }

    BlockStatement methodBody = new BlockStatement();
    ArgumentListExpression arguments = new ArgumentListExpression();

    for (Parameter parameterType : parameterTypes) {
      arguments.addExpression(new VariableExpression(parameterType.getName()));
    }
    MethodCallExpression methodCallExpression =
        new MethodCallExpression(expression, declaredMethodName, arguments);
    methodCallExpression.setMethodTarget(delegateMethod);

    ThrowStatement missingMethodException = createMissingMethodThrowable(classNode, delegateMethod);
    VariableExpression apiVar = addApiVariableDeclaration(expression, delegateMethod, methodBody);
    IfStatement ifStatement =
        createIfElseStatementForApiMethodCall(methodCallExpression, apiVar, missingMethodException);

    methodBody.addStatement(ifStatement);
    ClassNode returnType = nonGeneric(delegateMethod.getReturnType());
    if (METHOD_MISSING_METHOD_NAME.equals(declaredMethodName)) {
      declaredMethodName = STATIC_METHOD_MISSING_METHOD_NAME;
    }
    MethodNode methodNode = classNode.getDeclaredMethod(declaredMethodName, parameterTypes);
    if (methodNode == null) {
      methodNode =
          new MethodNode(
              declaredMethodName,
              Modifier.PUBLIC | Modifier.STATIC,
              returnType,
              copyParameters(parameterTypes),
              GrailsArtefactClassInjector.EMPTY_CLASS_ARRAY,
              methodBody);
      methodNode.addAnnotations(delegateMethod.getAnnotations());

      classNode.addMethod(methodNode);
    }
    return methodNode;
  }

  /**
   * Adds or modifies an existing constructor to delegate to the given static constructor method for
   * initialization logic.
   *
   * @param classNode The class node
   * @param constructorMethod The constructor static method
   */
  public static void addDelegateConstructor(ClassNode classNode, MethodNode constructorMethod) {
    BlockStatement constructorBody = new BlockStatement();
    Parameter[] constructorParams = getRemainingParameterTypes(constructorMethod.getParameters());
    ArgumentListExpression arguments = createArgumentListFromParameters(constructorParams, true);
    MethodCallExpression constructCallExpression =
        new MethodCallExpression(
            new ClassExpression(constructorMethod.getDeclaringClass()), "initialize", arguments);
    constructCallExpression.setMethodTarget(constructorMethod);
    ExpressionStatement constructorInitExpression =
        new ExpressionStatement(constructCallExpression);
    if (constructorParams.length > 0) {
      constructorBody.addStatement(
          new ExpressionStatement(
              new ConstructorCallExpression(
                  ClassNode.THIS, GrailsArtefactClassInjector.ZERO_ARGS)));
    }
    constructorBody.addStatement(constructorInitExpression);

    if (constructorParams.length == 0) {
      // handle default constructor

      ConstructorNode constructorNode = getDefaultConstructor(classNode);
      if (constructorNode != null) {
        List<AnnotationNode> annotations =
            constructorNode.getAnnotations(new ClassNode(GrailsDelegatingConstructor.class));
        if (annotations.size() == 0) {
          Statement existingBodyCode = constructorNode.getCode();
          if (existingBodyCode instanceof BlockStatement) {
            ((BlockStatement) existingBodyCode).addStatement(constructorInitExpression);
          } else {
            constructorNode.setCode(constructorBody);
          }
        }
      } else {
        constructorNode = new ConstructorNode(Modifier.PUBLIC, constructorBody);
        classNode.addConstructor(constructorNode);
      }
      constructorNode.addAnnotation(
          new AnnotationNode(new ClassNode(GrailsDelegatingConstructor.class)));
    } else {
      // create new constructor, restoring default constructor if there is none
      ConstructorNode cn = findConstructor(classNode, constructorParams);
      if (cn == null) {
        cn =
            new ConstructorNode(
                Modifier.PUBLIC, copyParameters(constructorParams), null, constructorBody);
        classNode.addConstructor(cn);
      } else {
        List<AnnotationNode> annotations =
            cn.getAnnotations(new ClassNode(GrailsDelegatingConstructor.class));
        if (annotations.size() == 0) {
          Statement code = cn.getCode();
          constructorBody.addStatement(code);
          cn.setCode(constructorBody);
        }
      }

      ConstructorNode defaultConstructor = getDefaultConstructor(classNode);
      if (defaultConstructor == null) {
        // add empty
        classNode.addConstructor(new ConstructorNode(Modifier.PUBLIC, new BlockStatement()));
      }
      cn.addAnnotation(new AnnotationNode(new ClassNode(GrailsDelegatingConstructor.class)));
    }
  }

  /**
   * Finds a constructor for the given class node and parameter types
   *
   * @param classNode The class node
   * @param constructorParams The parameter types
   * @return The located constructor or null
   */
  public static ConstructorNode findConstructor(
      ClassNode classNode, Parameter[] constructorParams) {
    List<ConstructorNode> declaredConstructors = classNode.getDeclaredConstructors();
    for (ConstructorNode declaredConstructor : declaredConstructors) {
      if (parametersEqual(constructorParams, declaredConstructor.getParameters())) {
        return declaredConstructor;
      }
    }
    return null;
  }

  /** @return true if the two arrays are of the same size and have the same contents */
  public static boolean parametersEqual(Parameter[] a, Parameter[] b) {
    if (a.length != b.length) {
      return false;
    }

    for (int i = 0; i < a.length; i++) {
      if (!a[i].getType().equals(b[i].getType())) {
        return false;
      }
    }

    return true;
  }

  /**
   * Obtains the default constructor for the given class node.
   *
   * @param classNode The class node
   * @return The default constructor or null if there isn't one
   */
  public static ConstructorNode getDefaultConstructor(ClassNode classNode) {
    for (ConstructorNode cons : classNode.getDeclaredConstructors()) {
      if (cons.getParameters().length == 0) {
        return cons;
      }
    }
    return null;
  }

  private static Parameter[] copyParameters(Parameter[] parameterTypes) {
    Parameter[] newParameterTypes = new Parameter[parameterTypes.length];
    for (int i = 0; i < parameterTypes.length; i++) {
      Parameter parameterType = parameterTypes[i];
      Parameter newParameter =
          new Parameter(
              nonGeneric(parameterType.getType()),
              parameterType.getName(),
              parameterType.getInitialExpression());
      newParameter.addAnnotations(parameterType.getAnnotations());
      newParameterTypes[i] = newParameter;
    }
    return newParameterTypes;
  }

  public static ClassNode nonGeneric(ClassNode type) {
    if (type.isUsingGenerics()) {
      final ClassNode nonGen = ClassHelper.makeWithoutCaching(type.getName());
      nonGen.setRedirect(type);
      nonGen.setGenericsTypes(null);
      nonGen.setUsingGenerics(false);
      return nonGen;
    }

    if (type.isArray()) {
      final ClassNode nonGen = ClassHelper.makeWithoutCaching(Object.class);
      nonGen.setUsingGenerics(false);
      return nonGen.makeArray();
    }

    return type.getPlainNodeReference();
  }

  public static boolean isCandidateInstanceMethod(ClassNode classNode, MethodNode declaredMethod) {
    Parameter[] parameterTypes = declaredMethod.getParameters();
    return isCandidateMethod(declaredMethod)
        && parameterTypes != null
        && parameterTypes.length > 0
        && isAssignableFrom(parameterTypes[0].getType(), classNode);
  }

  /**
   * Determines if the class or interface represented by the superClass argument is either the same
   * as, or is a superclass or superinterface of, the class or interface represented by the
   * specified subClass parameter.
   *
   * @param superClass The super class to check
   * @param childClass The sub class the check
   * @return true if the childClass is either equal to or a sub class of the specified superClass
   */
  private static boolean isAssignableFrom(ClassNode superClass, ClassNode childClass) {
    ClassNode currentSuper = childClass;
    while (currentSuper != null) {
      if (currentSuper.equals(superClass)) {
        return true;
      }

      currentSuper = currentSuper.getSuperClass();
    }
    return false;
  }

  public static boolean isCandidateMethod(MethodNode declaredMethod) {
    return !declaredMethod.isSynthetic()
        && !declaredMethod.getName().contains("$")
        && Modifier.isPublic(declaredMethod.getModifiers())
        && !Modifier.isAbstract(declaredMethod.getModifiers());
  }

  public static boolean isConstructorMethod(MethodNode declaredMethod) {
    return declaredMethod.isStatic()
        && declaredMethod.isPublic()
        && declaredMethod.getName().equals("initialize")
        && declaredMethod.getParameters().length >= 1
        && declaredMethod
            .getParameters()[0]
            .getType()
            .equals(AbstractGrailsArtefactTransformer.OBJECT_CLASS);
  }

  public static void addDelegateInstanceMethods(
      ClassNode classNode, ClassNode delegateNode, Expression delegateInstance) {
    addDelegateInstanceMethods(classNode, classNode, delegateNode, delegateInstance);
  }

  public static void addDelegateInstanceMethods(
      ClassNode supportedSuperType,
      ClassNode classNode,
      ClassNode delegateNode,
      Expression delegateInstance) {
    while (!delegateNode.equals(AbstractGrailsArtefactTransformer.OBJECT_CLASS)) {
      List<MethodNode> declaredMethods = delegateNode.getMethods();
      for (MethodNode declaredMethod : declaredMethods) {

        if (isConstructorMethod(declaredMethod)) {
          addDelegateConstructor(classNode, declaredMethod);

        } else if (isCandidateInstanceMethod(supportedSuperType, declaredMethod)) {
          addDelegateInstanceMethod(classNode, delegateInstance, declaredMethod);
        }
      }
      delegateNode = delegateNode.getSuperClass();
    }
  }

  public static void addFieldIfNonExistent(
      ClassNode classNode, ClassNode fieldType, String fieldName) {
    if (classNode != null && classNode.getField(fieldName) == null) {
      classNode.addField(
          fieldName,
          Modifier.PRIVATE,
          fieldType,
          new ConstructorCallExpression(fieldType, new ArgumentListExpression()));
    }
  }

  public static void addAnnotationIfNecessary(
      ClassNode classNode, @SuppressWarnings("unused") Class<Entity> entityClass) {
    List<AnnotationNode> annotations = classNode.getAnnotations();
    ClassNode annotationClassNode = new ClassNode(Entity.class);
    AnnotationNode annotationToAdd = new AnnotationNode(annotationClassNode);
    if (annotations.isEmpty()) {
      classNode.addAnnotation(annotationToAdd);
    } else {
      boolean foundAnn = findAnnotation(annotationClassNode, annotations) != null;
      if (!foundAnn) classNode.addAnnotation(annotationToAdd);
    }
  }

  public static AnnotationNode findAnnotation(
      ClassNode annotationClassNode, List<AnnotationNode> annotations) {
    for (AnnotationNode annotation : annotations) {
      if (annotation.getClassNode().equals(annotationClassNode)) {
        return annotation;
      }
    }
    return null;
  }

  public static AnnotationNode findAnnotation(ClassNode classNode, Class type) {
    List<AnnotationNode> annotations = classNode.getAnnotations();
    if (annotations != null) {
      return findAnnotation(new ClassNode(type), annotations);
    }
    return null;
  }

  /**
   * Returns true if classNode is marked with annotationClass
   *
   * @param classNode A ClassNode to inspect
   * @param annotationClass an annotation to look for
   * @return true if classNode is marked with annotationClass, otherwise false
   */
  public static boolean hasAnnotation(
      final ClassNode classNode, final Class<? extends Annotation> annotationClass) {
    List<AnnotationNode> annotations = classNode.getAnnotations(new ClassNode(annotationClass));
    return annotations.size() > 0;
  }

  /**
   * @param classNode a ClassNode to search
   * @param annotationsToLookFor Annotations to look for
   * @return true if classNode is marked with any of the annotations in annotationsToLookFor
   */
  public static boolean hasAnyAnnotations(
      final ClassNode classNode, final Class<? extends Annotation>... annotationsToLookFor) {
    return CollectionUtils.exists(
        Arrays.asList(annotationsToLookFor),
        new Predicate() {
          @SuppressWarnings({"unchecked", "rawtypes"})
          public boolean evaluate(Object object) {
            return hasAnnotation(classNode, (Class) object);
          }
        });
  }

  public static void addMethodIfNotPresent(ClassNode controllerClassNode, MethodNode methodNode) {
    MethodNode existing =
        controllerClassNode.getMethod(methodNode.getName(), methodNode.getParameters());
    if (existing == null) {
      controllerClassNode.addMethod(methodNode);
    }
  }

  public static ExpressionStatement createPrintlnStatement(String message) {
    return new ExpressionStatement(
        new MethodCallExpression(
            AbstractGrailsArtefactTransformer.THIS_EXPRESSION,
            "println",
            new ArgumentListExpression(new ConstantExpression(message))));
  }

  public static ExpressionStatement createPrintlnStatement(String message, String variable) {
    return new ExpressionStatement(
        new MethodCallExpression(
            AbstractGrailsArtefactTransformer.THIS_EXPRESSION,
            "println",
            new ArgumentListExpression(
                new BinaryExpression(
                    new ConstantExpression(message),
                    Token.newSymbol(Types.PLUS, 0, 0),
                    new VariableExpression(variable)))));
  }

  /**
   * Wraps a method body in try / catch logic that catches any errors and logs an error, but does
   * not rethrow!
   *
   * @param methodNode The method node
   */
  public static void wrapMethodBodyInTryCatchDebugStatements(MethodNode methodNode) {
    BlockStatement code = (BlockStatement) methodNode.getCode();
    BlockStatement newCode = new BlockStatement();
    TryCatchStatement tryCatchStatement = new TryCatchStatement(code, new BlockStatement());
    newCode.addStatement(tryCatchStatement);
    methodNode.setCode(newCode);
    BlockStatement catchBlock = new BlockStatement();
    ArgumentListExpression logArguments = new ArgumentListExpression();
    logArguments.addExpression(
        new BinaryExpression(
            new ConstantExpression("Error initializing class: "),
            Token.newSymbol(Types.PLUS, 0, 0),
            new VariableExpression("e")));
    logArguments.addExpression(new VariableExpression("e"));
    catchBlock.addStatement(
        new ExpressionStatement(
            new MethodCallExpression(new VariableExpression("log"), "error", logArguments)));
    tryCatchStatement.addCatch(
        new CatchStatement(new Parameter(new ClassNode(Throwable.class), "e"), catchBlock));
  }

  /**
   * Evaluates a constraints closure and returns metadata about the constraints configured in the
   * closure. The Map returned has property names as keys and the value associated with each of
   * those property names is a Map<String, Expression> which has constraint names as keys and the
   * Expression associated with that constraint as values
   *
   * @param closureExpression the closure expression to evaluate
   * @return the Map as described above
   */
  public static Map<String, Map<String, Expression>> getConstraintMetadata(
      final ClosureExpression closureExpression) {

    final List<MethodCallExpression> methodExpressions = new ArrayList<MethodCallExpression>();

    final Map<String, Map<String, Expression>> results =
        new LinkedHashMap<String, Map<String, Expression>>();
    final Statement closureCode = closureExpression.getCode();
    if (closureCode instanceof BlockStatement) {
      final List<Statement> closureStatements = ((BlockStatement) closureCode).getStatements();
      for (final Statement closureStatement : closureStatements) {
        if (closureStatement instanceof ExpressionStatement) {
          final Expression expression = ((ExpressionStatement) closureStatement).getExpression();
          if (expression instanceof MethodCallExpression) {
            methodExpressions.add((MethodCallExpression) expression);
          }
        } else if (closureStatement instanceof ReturnStatement) {
          final ReturnStatement returnStatement = (ReturnStatement) closureStatement;
          Expression expression = returnStatement.getExpression();
          if (expression instanceof MethodCallExpression) {
            methodExpressions.add((MethodCallExpression) expression);
          }
        }

        for (final MethodCallExpression methodCallExpression : methodExpressions) {
          final Expression objectExpression = methodCallExpression.getObjectExpression();
          if (objectExpression instanceof VariableExpression
              && "this".equals(((VariableExpression) objectExpression).getName())) {
            final Expression methodCallArguments = methodCallExpression.getArguments();
            if (methodCallArguments instanceof TupleExpression) {
              final List<Expression> methodCallArgumentExpressions =
                  ((TupleExpression) methodCallArguments).getExpressions();
              if (methodCallArgumentExpressions != null
                  && methodCallArgumentExpressions.size() == 1
                  && methodCallArgumentExpressions.get(0) instanceof NamedArgumentListExpression) {
                final Map<String, Expression> constraintNameToExpression =
                    new LinkedHashMap<String, Expression>();
                final List<MapEntryExpression> mapEntryExpressions =
                    ((NamedArgumentListExpression) methodCallArgumentExpressions.get(0))
                        .getMapEntryExpressions();
                for (final MapEntryExpression mapEntryExpression : mapEntryExpressions) {
                  final Expression keyExpression = mapEntryExpression.getKeyExpression();
                  if (keyExpression instanceof ConstantExpression) {
                    final Object value = ((ConstantExpression) keyExpression).getValue();
                    if (value instanceof String) {
                      constraintNameToExpression.put(
                          (String) value, mapEntryExpression.getValueExpression());
                    }
                  }
                }
                results.put(methodCallExpression.getMethodAsString(), constraintNameToExpression);
              }
            }
          }
        }
      }
    }
    return results;
  }

  @Target(ElementType.CONSTRUCTOR)
  @Retention(RetentionPolicy.SOURCE)
  private static @interface GrailsDelegatingConstructor {}
}
/**
 * Handy methods when working with the Groovy AST
 *
 * @author Guillaume Laforge
 * @author Paul King
 * @author Andre Steingress
 * @author Graeme Rocher
 */
public class GeneralUtils {
  public static final Token ASSIGN = Token.newSymbol(Types.ASSIGN, -1, -1);
  public static final Token EQ = Token.newSymbol(Types.COMPARE_EQUAL, -1, -1);
  public static final Token NE = Token.newSymbol(Types.COMPARE_NOT_EQUAL, -1, -1);
  public static final Token LT = Token.newSymbol(Types.COMPARE_LESS_THAN, -1, -1);
  public static final Token AND = Token.newSymbol(Types.LOGICAL_AND, -1, -1);
  public static final Token OR = Token.newSymbol(Types.LOGICAL_OR, -1, -1);
  public static final Token CMP = Token.newSymbol(Types.COMPARE_TO, -1, -1);
  private static final Token INSTANCEOF = Token.newSymbol(Types.KEYWORD_INSTANCEOF, -1, -1);
  private static final Token PLUS = Token.newSymbol(Types.PLUS, -1, -1);
  private static final Token INDEX = Token.newSymbol("[", -1, -1);

  public static BinaryExpression andX(Expression lhv, Expression rhv) {
    return new BinaryExpression(lhv, AND, rhv);
  }

  public static ArgumentListExpression args(Expression... expressions) {
    List<Expression> args = new ArrayList<Expression>();
    Collections.addAll(args, expressions);
    return new ArgumentListExpression(args);
  }

  public static ArgumentListExpression args(List<Expression> expressions) {
    return new ArgumentListExpression(expressions);
  }

  public static ArgumentListExpression args(Parameter[] parameters) {
    return new ArgumentListExpression(parameters);
  }

  public static ArgumentListExpression args(String... names) {
    List<Expression> vars = new ArrayList<Expression>();
    for (String name : names) {
      vars.add(varX(name));
    }
    return new ArgumentListExpression(vars);
  }

  public static Statement assignS(Expression target, Expression value) {
    return new ExpressionStatement(assignX(target, value));
  }

  public static Expression assignX(Expression target, Expression value) {
    return new BinaryExpression(target, ASSIGN, value);
  }

  public static Expression attrX(Expression oe, Expression prop) {
    return new AttributeExpression(oe, prop);
  }

  public static BlockStatement block(VariableScope varScope, Statement... stmts) {
    BlockStatement block = new BlockStatement();
    block.setVariableScope(varScope);
    for (Statement stmt : stmts) block.addStatement(stmt);
    return block;
  }

  public static BlockStatement block(Statement... stmts) {
    BlockStatement block = new BlockStatement();
    for (Statement stmt : stmts) block.addStatement(stmt);
    return block;
  }

  public static MethodCallExpression callSuperX(String methodName, Expression args) {
    return callX(varX("super"), methodName, args);
  }

  public static MethodCallExpression callSuperX(String methodName) {
    return callSuperX(methodName, MethodCallExpression.NO_ARGUMENTS);
  }

  public static MethodCallExpression callThisX(String methodName, Expression args) {
    return callX(varX("this"), methodName, args);
  }

  public static MethodCallExpression callThisX(String methodName) {
    return callThisX(methodName, MethodCallExpression.NO_ARGUMENTS);
  }

  public static MethodCallExpression callX(
      Expression receiver, String methodName, Expression args) {
    return new MethodCallExpression(receiver, methodName, args);
  }

  public static MethodCallExpression callX(
      Expression receiver, Expression method, Expression args) {
    return new MethodCallExpression(receiver, method, args);
  }

  public static MethodCallExpression callX(Expression receiver, String methodName) {
    return callX(receiver, methodName, MethodCallExpression.NO_ARGUMENTS);
  }

  public static StaticMethodCallExpression callX(
      ClassNode receiver, String methodName, Expression args) {
    return new StaticMethodCallExpression(receiver, methodName, args);
  }

  public static StaticMethodCallExpression callX(ClassNode receiver, String methodName) {
    return callX(receiver, methodName, MethodCallExpression.NO_ARGUMENTS);
  }

  public static CastExpression castX(ClassNode type, Expression expression) {
    return new CastExpression(type, expression);
  }

  public static CastExpression castX(
      ClassNode type, Expression expression, boolean ignoreAutoboxing) {
    return new CastExpression(type, expression, ignoreAutoboxing);
  }

  public static ClassExpression classX(ClassNode clazz) {
    return new ClassExpression(clazz);
  }

  public static ClassExpression classX(Class clazz) {
    return classX(ClassHelper.make(clazz).getPlainNodeReference());
  }

  public static ClosureExpression closureX(Parameter[] params, Statement code) {
    return new ClosureExpression(params, code);
  }

  public static ClosureExpression closureX(Statement code) {
    return closureX(Parameter.EMPTY_ARRAY, code);
  }

  public static Parameter[] cloneParams(Parameter[] source) {
    Parameter[] result = new Parameter[source.length];
    for (int i = 0; i < source.length; i++) {
      Parameter srcParam = source[i];
      Parameter dstParam = new Parameter(srcParam.getOriginType(), srcParam.getName());
      result[i] = dstParam;
    }
    return result;
  }

  public static BinaryExpression cmpX(Expression lhv, Expression rhv) {
    return new BinaryExpression(lhv, CMP, rhv);
  }

  public static ConstantExpression constX(Object val) {
    return new ConstantExpression(val);
  }

  public static ConstantExpression constX(Object val, boolean keepPrimitive) {
    return new ConstantExpression(val, keepPrimitive);
  }

  /**
   * Copies all <tt>candidateAnnotations</tt> with retention policy {@link
   * java.lang.annotation.RetentionPolicy#RUNTIME} and {@link
   * java.lang.annotation.RetentionPolicy#CLASS}.
   *
   * <p>Annotations with {@link org.codehaus.groovy.runtime.GeneratedClosure} members are not
   * supported at present.
   */
  public static void copyAnnotatedNodeAnnotations(
      final AnnotatedNode annotatedNode,
      final List<AnnotationNode> copied,
      List<AnnotationNode> notCopied) {
    List<AnnotationNode> annotationList = annotatedNode.getAnnotations();
    for (AnnotationNode annotation : annotationList) {

      List<AnnotationNode> annotations =
          annotation.getClassNode().getAnnotations(AbstractASTTransformation.RETENTION_CLASSNODE);
      if (annotations.isEmpty()) continue;

      if (hasClosureMember(annotation)) {
        notCopied.add(annotation);
        continue;
      }

      AnnotationNode retentionPolicyAnnotation = annotations.get(0);
      Expression valueExpression = retentionPolicyAnnotation.getMember("value");
      if (!(valueExpression instanceof PropertyExpression)) continue;

      PropertyExpression propertyExpression = (PropertyExpression) valueExpression;
      boolean processAnnotation =
          propertyExpression.getProperty() instanceof ConstantExpression
              && ("RUNTIME"
                      .equals(((ConstantExpression) (propertyExpression.getProperty())).getValue())
                  || "CLASS"
                      .equals(
                          ((ConstantExpression) (propertyExpression.getProperty())).getValue()));

      if (processAnnotation) {
        AnnotationNode newAnnotation = new AnnotationNode(annotation.getClassNode());
        for (Map.Entry<String, Expression> member : annotation.getMembers().entrySet()) {
          newAnnotation.addMember(member.getKey(), member.getValue());
        }
        newAnnotation.setSourcePosition(annotatedNode);

        copied.add(newAnnotation);
      }
    }
  }

  public static Statement createConstructorStatementDefault(FieldNode fNode) {
    final String name = fNode.getName();
    final ClassNode fType = fNode.getType();
    final Expression fieldExpr = propX(varX("this"), name);
    Expression initExpr = fNode.getInitialValueExpression();
    Statement assignInit;
    if (initExpr == null
        || (initExpr instanceof ConstantExpression
            && ((ConstantExpression) initExpr).isNullExpression())) {
      if (ClassHelper.isPrimitiveType(fType)) {
        assignInit = EmptyStatement.INSTANCE;
      } else {
        assignInit = assignS(fieldExpr, ConstantExpression.EMPTY_EXPRESSION);
      }
    } else {
      assignInit = assignS(fieldExpr, initExpr);
    }
    fNode.setInitialValueExpression(null);
    Expression value = findArg(name);
    return ifElseS(equalsNullX(value), assignInit, assignS(fieldExpr, castX(fType, value)));
  }

  public static ConstructorCallExpression ctorX(ClassNode type, Expression args) {
    return new ConstructorCallExpression(type, args);
  }

  public static ConstructorCallExpression ctorX(ClassNode type) {
    return new ConstructorCallExpression(type, ArgumentListExpression.EMPTY_ARGUMENTS);
  }

  public static Statement ctorSuperS(Expression args) {
    return stmt(ctorX(ClassNode.SUPER, args));
  }

  public static Statement ctorThisS(Expression args) {
    return stmt(ctorX(ClassNode.THIS, args));
  }

  public static Statement ctorSuperS() {
    return stmt(ctorX(ClassNode.SUPER));
  }

  public static Statement ctorThisS() {
    return stmt(ctorX(ClassNode.THIS));
  }

  public static Statement declS(Expression target, Expression init) {
    return new ExpressionStatement(new DeclarationExpression(target, ASSIGN, init));
  }

  public static BinaryExpression eqX(Expression lhv, Expression rhv) {
    return new BinaryExpression(lhv, EQ, rhv);
  }

  public static BooleanExpression equalsNullX(Expression argExpr) {
    return new BooleanExpression(eqX(argExpr, new ConstantExpression(null)));
  }

  public static FieldExpression fieldX(FieldNode fieldNode) {
    return new FieldExpression(fieldNode);
  }

  public static FieldExpression fieldX(ClassNode owner, String fieldName) {
    return new FieldExpression(owner.getField(fieldName));
  }

  public static Expression findArg(String argName) {
    return new PropertyExpression(new VariableExpression("args"), argName);
  }

  public static List<MethodNode> getAllMethods(ClassNode type) {
    ClassNode node = type;
    List<MethodNode> result = new ArrayList<MethodNode>();
    while (node != null) {
      result.addAll(node.getMethods());
      node = node.getSuperClass();
    }
    return result;
  }

  public static List<PropertyNode> getAllProperties(ClassNode type) {
    ClassNode node = type;
    List<PropertyNode> result = new ArrayList<PropertyNode>();
    while (node != null) {
      result.addAll(node.getProperties());
      node = node.getSuperClass();
    }
    return result;
  }

  public static String getGetterName(PropertyNode pNode) {
    return "get" + Verifier.capitalize(pNode.getName());
  }

  public static List<FieldNode> getInstanceNonPropertyFields(ClassNode cNode) {
    final List<FieldNode> result = new ArrayList<FieldNode>();
    for (FieldNode fNode : cNode.getFields()) {
      if (!fNode.isStatic() && cNode.getProperty(fNode.getName()) == null) {
        result.add(fNode);
      }
    }
    return result;
  }

  public static List<String> getInstanceNonPropertyFieldNames(ClassNode cNode) {
    List<FieldNode> fList = getInstanceNonPropertyFields(cNode);
    List<String> result = new ArrayList<String>(fList.size());
    for (FieldNode fNode : fList) {
      result.add(fNode.getName());
    }
    return result;
  }

  public static List<PropertyNode> getInstanceProperties(ClassNode cNode) {
    final List<PropertyNode> result = new ArrayList<PropertyNode>();
    for (PropertyNode pNode : cNode.getProperties()) {
      if (!pNode.isStatic()) {
        result.add(pNode);
      }
    }
    return result;
  }

  public static List<String> getInstancePropertyNames(ClassNode cNode) {
    List<PropertyNode> pList = BeanUtils.getAllProperties(cNode, false, false, true);
    List<String> result = new ArrayList<String>(pList.size());
    for (PropertyNode pNode : pList) {
      result.add(pNode.getName());
    }
    return result;
  }

  public static List<FieldNode> getInstancePropertyFields(ClassNode cNode) {
    final List<FieldNode> result = new ArrayList<FieldNode>();
    for (PropertyNode pNode : cNode.getProperties()) {
      if (!pNode.isStatic()) {
        result.add(pNode.getField());
      }
    }
    return result;
  }

  public static Set<ClassNode> getInterfacesAndSuperInterfaces(ClassNode type) {
    Set<ClassNode> res = new HashSet<ClassNode>();
    if (type.isInterface()) {
      res.add(type);
      return res;
    }
    ClassNode next = type;
    while (next != null) {
      Collections.addAll(res, next.getInterfaces());
      next = next.getSuperClass();
    }
    return res;
  }

  public static List<FieldNode> getSuperNonPropertyFields(ClassNode cNode) {
    final List<FieldNode> result;
    if (cNode == ClassHelper.OBJECT_TYPE) {
      result = new ArrayList<FieldNode>();
    } else {
      result = getSuperNonPropertyFields(cNode.getSuperClass());
    }
    for (FieldNode fNode : cNode.getFields()) {
      if (!fNode.isStatic() && cNode.getProperty(fNode.getName()) == null) {
        result.add(fNode);
      }
    }
    return result;
  }

  public static List<FieldNode> getSuperPropertyFields(ClassNode cNode) {
    final List<FieldNode> result;
    if (cNode == ClassHelper.OBJECT_TYPE) {
      result = new ArrayList<FieldNode>();
    } else {
      result = getSuperPropertyFields(cNode.getSuperClass());
    }
    for (PropertyNode pNode : cNode.getProperties()) {
      if (!pNode.isStatic()) {
        result.add(pNode.getField());
      }
    }
    return result;
  }

  public static BinaryExpression hasClassX(Expression instance, ClassNode cNode) {
    return eqX(classX(cNode), callX(instance, "getClass"));
  }

  private static boolean hasClosureMember(AnnotationNode annotation) {

    Map<String, Expression> members = annotation.getMembers();
    for (Map.Entry<String, Expression> member : members.entrySet()) {
      if (member.getValue() instanceof ClosureExpression) return true;

      if (member.getValue() instanceof ClassExpression) {
        ClassExpression classExpression = (ClassExpression) member.getValue();
        Class<?> typeClass =
            classExpression.getType().isResolved()
                ? classExpression.getType().redirect().getTypeClass()
                : null;
        if (typeClass != null && GeneratedClosure.class.isAssignableFrom(typeClass)) return true;
      }
    }

    return false;
  }

  public static boolean hasDeclaredMethod(ClassNode cNode, String name, int argsCount) {
    List<MethodNode> ms = cNode.getDeclaredMethods(name);
    for (MethodNode m : ms) {
      Parameter[] paras = m.getParameters();
      if (paras != null && paras.length == argsCount) {
        return true;
      }
    }
    return false;
  }

  public static BinaryExpression hasEqualFieldX(FieldNode fNode, Expression other) {
    return eqX(varX(fNode), propX(other, fNode.getName()));
  }

  public static BinaryExpression hasEqualPropertyX(
      ClassNode annotatedNode, PropertyNode pNode, VariableExpression other) {
    return eqX(getterThisX(annotatedNode, pNode), getterX(other.getOriginType(), other, pNode));
  }

  @Deprecated
  public static BinaryExpression hasEqualPropertyX(PropertyNode pNode, Expression other) {
    String getterName = getGetterName(pNode);
    return eqX(callThisX(getterName), callX(other, getterName));
  }

  public static BooleanExpression hasSameFieldX(FieldNode fNode, Expression other) {
    return sameX(varX(fNode), propX(other, fNode.getName()));
  }

  public static BooleanExpression hasSamePropertyX(PropertyNode pNode, Expression other) {
    String getterName = getGetterName(pNode);
    return sameX(callThisX(getterName), callX(other, getterName));
  }

  public static Statement ifElseS(Expression cond, Statement thenStmt, Statement elseStmt) {
    return new IfStatement(
        cond instanceof BooleanExpression ? (BooleanExpression) cond : new BooleanExpression(cond),
        thenStmt,
        elseStmt);
  }

  public static Statement ifS(Expression cond, Expression trueExpr) {
    return ifS(cond, new ExpressionStatement(trueExpr));
  }

  public static Statement ifS(Expression cond, Statement trueStmt) {
    return new IfStatement(
        cond instanceof BooleanExpression ? (BooleanExpression) cond : new BooleanExpression(cond),
        trueStmt,
        EmptyStatement.INSTANCE);
  }

  public static Expression indexX(Expression target, Expression value) {
    return new BinaryExpression(target, INDEX, value);
  }

  public static BooleanExpression isInstanceOfX(Expression objectExpression, ClassNode cNode) {
    return new BooleanExpression(new BinaryExpression(objectExpression, INSTANCEOF, classX(cNode)));
  }

  public static BooleanExpression isOneX(Expression expr) {
    return new BooleanExpression(new BinaryExpression(expr, EQ, new ConstantExpression(1)));
  }

  public static boolean isOrImplements(ClassNode type, ClassNode interfaceType) {
    return type.equals(interfaceType) || type.implementsInterface(interfaceType);
  }

  public static BooleanExpression isTrueX(Expression argExpr) {
    return new BooleanExpression(
        new BinaryExpression(argExpr, EQ, new ConstantExpression(Boolean.TRUE)));
  }

  public static BooleanExpression isZeroX(Expression expr) {
    return new BooleanExpression(new BinaryExpression(expr, EQ, new ConstantExpression(0)));
  }

  public static BinaryExpression ltX(Expression lhv, Expression rhv) {
    return new BinaryExpression(lhv, LT, rhv);
  }

  public static String makeDescriptorWithoutReturnType(MethodNode mn) {
    StringBuilder sb = new StringBuilder();
    sb.append(mn.getName()).append(':');
    for (Parameter p : mn.getParameters()) {
      sb.append(p.getType()).append(',');
    }
    return sb.toString();
  }

  public static BinaryExpression neX(Expression lhv, Expression rhv) {
    return new BinaryExpression(lhv, NE, rhv);
  }

  public static BooleanExpression notNullX(Expression argExpr) {
    return new BooleanExpression(new BinaryExpression(argExpr, NE, new ConstantExpression(null)));
  }

  public static NotExpression notX(Expression expr) {
    return new NotExpression(
        expr instanceof BooleanExpression ? expr : new BooleanExpression(expr));
  }

  public static BinaryExpression orX(Expression lhv, Expression rhv) {
    return new BinaryExpression(lhv, OR, rhv);
  }

  public static Parameter param(ClassNode type, String name) {
    return param(type, name, null);
  }

  public static Parameter param(ClassNode type, String name, Expression initialExpression) {
    Parameter param = new Parameter(type, name);
    if (initialExpression != null) {
      param.setInitialExpression(initialExpression);
    }
    return param;
  }

  public static Parameter[] params(Parameter... params) {
    return params != null ? params : Parameter.EMPTY_ARRAY;
  }

  public static BinaryExpression plusX(Expression lhv, Expression rhv) {
    return new BinaryExpression(lhv, PLUS, rhv);
  }

  public static Expression propX(Expression owner, String property) {
    return new PropertyExpression(owner, property);
  }

  public static Expression propX(Expression owner, Expression property) {
    return new PropertyExpression(owner, property);
  }

  public static Statement returnS(Expression expr) {
    return new ReturnStatement(new ExpressionStatement(expr));
  }

  public static Statement safeExpression(Expression fieldExpr, Expression expression) {
    return new IfStatement(
        equalsNullX(fieldExpr),
        new ExpressionStatement(fieldExpr),
        new ExpressionStatement(expression));
  }

  public static BooleanExpression sameX(Expression self, Expression other) {
    return new BooleanExpression(callX(self, "is", args(other)));
  }

  public static Statement stmt(Expression expr) {
    return new ExpressionStatement(expr);
  }

  public static TernaryExpression ternaryX(
      Expression cond, Expression trueExpr, Expression elseExpr) {
    return new TernaryExpression(
        cond instanceof BooleanExpression ? (BooleanExpression) cond : new BooleanExpression(cond),
        trueExpr,
        elseExpr);
  }

  public static VariableExpression varX(String name) {
    return new VariableExpression(name);
  }

  public static VariableExpression varX(Variable variable) {
    return new VariableExpression(variable);
  }

  public static VariableExpression varX(String name, ClassNode type) {
    return new VariableExpression(name, type);
  }

  /**
   * This method is similar to {@link #propX(Expression, Expression)} but will make sure that if the
   * property being accessed is defined inside the classnode provided as a parameter, then a getter
   * call is generated instead of a field access.
   *
   * @param annotatedNode the class node where the property node is accessed from
   * @param pNode the property being accessed
   * @return a method call expression or a property expression
   */
  public static Expression getterThisX(ClassNode annotatedNode, PropertyNode pNode) {
    ClassNode owner = pNode.getDeclaringClass();
    if (annotatedNode.equals(owner)) {
      String getterName = "get" + MetaClassHelper.capitalize(pNode.getName());
      boolean existingExplicitGetter =
          annotatedNode.getMethod(getterName, Parameter.EMPTY_ARRAY) != null;
      if (ClassHelper.boolean_TYPE.equals(pNode.getOriginType()) && !existingExplicitGetter) {
        getterName = "is" + MetaClassHelper.capitalize(pNode.getName());
      }
      return callThisX(getterName);
    }
    return propX(new VariableExpression("this"), pNode.getName());
  }

  /**
   * This method is similar to {@link #propX(Expression, Expression)} but will make sure that if the
   * property being accessed is defined inside the classnode provided as a parameter, then a getter
   * call is generated instead of a field access.
   *
   * @param annotatedNode the class node where the property node is accessed from
   * @param receiver the object having the property
   * @param pNode the property being accessed
   * @return a method call expression or a property expression
   */
  public static Expression getterX(
      ClassNode annotatedNode, Expression receiver, PropertyNode pNode) {
    ClassNode owner = pNode.getDeclaringClass();
    if (annotatedNode.equals(owner)) {
      String getterName = "get" + MetaClassHelper.capitalize(pNode.getName());
      boolean existingExplicitGetter =
          annotatedNode.getMethod(getterName, Parameter.EMPTY_ARRAY) != null;
      if (ClassHelper.boolean_TYPE.equals(pNode.getOriginType()) && !existingExplicitGetter) {
        getterName = "is" + MetaClassHelper.capitalize(pNode.getName());
      }
      return callX(receiver, getterName);
    }
    return propX(receiver, pNode.getName());
  }
}
Exemplo n.º 12
0
  Expression transformBinaryExpression(final BinaryExpression bin) {
    if (bin instanceof DeclarationExpression) {
      Expression optimized = transformDeclarationExpression(bin);
      if (optimized != null) {
        return optimized;
      }
    }
    Object[] list = bin.getNodeMetaData(BINARY_EXP_TARGET);
    Token operation = bin.getOperation();
    int operationType = operation.getType();
    Expression rightExpression = bin.getRightExpression();
    Expression leftExpression = bin.getLeftExpression();
    if (bin instanceof DeclarationExpression && leftExpression instanceof VariableExpression) {
      ClassNode declarationType = ((VariableExpression) leftExpression).getOriginType();
      if (rightExpression instanceof ConstantExpression) {
        ClassNode unwrapper = ClassHelper.getUnwrapper(declarationType);
        ClassNode wrapper = ClassHelper.getWrapper(declarationType);
        if (!rightExpression.getType().equals(declarationType)
            && wrapper.isDerivedFrom(ClassHelper.Number_TYPE)
            && WideningCategories.isDoubleCategory(unwrapper)) {
          ConstantExpression constant = (ConstantExpression) rightExpression;
          if (constant.getValue() != null) {
            return optimizeConstantInitialization(
                bin, operation, constant, leftExpression, declarationType);
          }
        }
      }
    }
    if (operationType == Types.EQUAL && leftExpression instanceof PropertyExpression) {
      MethodNode directMCT =
          leftExpression.getNodeMetaData(StaticTypesMarker.DIRECT_METHOD_CALL_TARGET);
      if (directMCT != null) {
        return transformPropertyAssignmentToSetterCall(
            (PropertyExpression) leftExpression, rightExpression, directMCT);
      }
    }
    if (operationType == Types.COMPARE_EQUAL || operationType == Types.COMPARE_NOT_EQUAL) {
      // let's check if one of the operands is the null constant
      CompareToNullExpression compareToNullExpression = null;
      if (isNullConstant(leftExpression)) {
        compareToNullExpression =
            new CompareToNullExpression(
                staticCompilationTransformer.transform(rightExpression),
                operationType == Types.COMPARE_EQUAL);
      } else if (isNullConstant(rightExpression)) {
        compareToNullExpression =
            new CompareToNullExpression(
                staticCompilationTransformer.transform(leftExpression),
                operationType == Types.COMPARE_EQUAL);
      }
      if (compareToNullExpression != null) {
        compareToNullExpression.setSourcePosition(bin);
        return compareToNullExpression;
      }
    } else if (operationType == Types.KEYWORD_IN) {
      return convertInOperatorToTernary(bin, rightExpression, leftExpression);
    }
    if (list != null) {
      if (operationType == Types.COMPARE_TO) {
        StaticTypesTypeChooser typeChooser = staticCompilationTransformer.getTypeChooser();
        ClassNode classNode = staticCompilationTransformer.getClassNode();
        ClassNode leftType = typeChooser.resolveType(leftExpression, classNode);
        if (leftType.implementsInterface(ClassHelper.COMPARABLE_TYPE)) {
          ClassNode rightType = typeChooser.resolveType(rightExpression, classNode);
          if (rightType.implementsInterface(ClassHelper.COMPARABLE_TYPE)) {
            Expression left = staticCompilationTransformer.transform(leftExpression);
            Expression right = staticCompilationTransformer.transform(rightExpression);
            MethodCallExpression call =
                new MethodCallExpression(left, "compareTo", new ArgumentListExpression(right));
            call.setImplicitThis(false);
            call.setMethodTarget(COMPARE_TO_METHOD);

            CompareIdentityExpression compareIdentity = new CompareIdentityExpression(left, right);
            compareIdentity.putNodeMetaData(
                StaticTypesMarker.INFERRED_RETURN_TYPE, ClassHelper.boolean_TYPE);
            TernaryExpression result =
                new TernaryExpression(
                    new BooleanExpression(compareIdentity), // a==b
                    CONSTANT_ZERO,
                    new TernaryExpression(
                        new BooleanExpression(new CompareToNullExpression(left, true)), // a==null
                        CONSTANT_MINUS_ONE,
                        new TernaryExpression(
                            new BooleanExpression(
                                new CompareToNullExpression(right, true)), // b==null
                            CONSTANT_ONE,
                            call)));
            compareIdentity.putNodeMetaData(
                StaticTypesMarker.INFERRED_RETURN_TYPE, ClassHelper.int_TYPE);
            result.putNodeMetaData(StaticTypesMarker.INFERRED_TYPE, ClassHelper.int_TYPE);
            TernaryExpression expr = (TernaryExpression) result.getFalseExpression();
            expr.putNodeMetaData(StaticTypesMarker.INFERRED_TYPE, ClassHelper.int_TYPE);
            expr.getFalseExpression()
                .putNodeMetaData(StaticTypesMarker.INFERRED_TYPE, ClassHelper.int_TYPE);
            return result;
          }
        }
      }
      boolean isAssignment = StaticTypeCheckingSupport.isAssignment(operationType);
      MethodCallExpression call;
      MethodNode node = (MethodNode) list[0];
      String name = (String) list[1];
      Expression left = staticCompilationTransformer.transform(leftExpression);
      Expression right = staticCompilationTransformer.transform(rightExpression);
      BinaryExpression optimized = tryOptimizeCharComparison(left, right, bin);
      if (optimized != null) {
        optimized.removeNodeMetaData(BINARY_EXP_TARGET);
        return transformBinaryExpression(optimized);
      }
      call = new MethodCallExpression(left, name, new ArgumentListExpression(right));
      call.setImplicitThis(false);
      call.setMethodTarget(node);
      MethodNode adapter = StaticCompilationTransformer.BYTECODE_BINARY_ADAPTERS.get(operationType);
      if (adapter != null) {
        ClassExpression sba =
            new ClassExpression(StaticCompilationTransformer.BYTECODE_ADAPTER_CLASS);
        // replace with compareEquals
        call =
            new MethodCallExpression(sba, "compareEquals", new ArgumentListExpression(left, right));
        call.setMethodTarget(adapter);
        call.setImplicitThis(false);
      }
      if (!isAssignment) return call;
      // case of +=, -=, /=, ...
      // the method represents the operation type only, and we must add an assignment
      return new BinaryExpression(
          left, Token.newSymbol("=", operation.getStartLine(), operation.getStartColumn()), call);
    }
    if (bin.getOperation().getType() == Types.EQUAL
        && leftExpression instanceof TupleExpression
        && rightExpression instanceof ListExpression) {
      // multiple assignment
      ListOfExpressionsExpression cle = new ListOfExpressionsExpression();
      boolean isDeclaration = bin instanceof DeclarationExpression;
      List<Expression> leftExpressions = ((TupleExpression) leftExpression).getExpressions();
      List<Expression> rightExpressions = ((ListExpression) rightExpression).getExpressions();
      Iterator<Expression> leftIt = leftExpressions.iterator();
      Iterator<Expression> rightIt = rightExpressions.iterator();
      if (isDeclaration) {
        while (leftIt.hasNext()) {
          Expression left = leftIt.next();
          if (rightIt.hasNext()) {
            Expression right = rightIt.next();
            BinaryExpression bexp = new DeclarationExpression(left, bin.getOperation(), right);
            bexp.setSourcePosition(right);
            cle.addExpression(bexp);
          }
        }
      } else {
        // (next, result) = [ result, next+result ]
        // -->
        // def tmp1 = result
        // def tmp2 = next+result
        // next = tmp1
        // result = tmp2
        int size = rightExpressions.size();
        List<Expression> tmpAssignments = new ArrayList<Expression>(size);
        List<Expression> finalAssignments = new ArrayList<Expression>(size);
        for (int i = 0; i < Math.min(size, leftExpressions.size()); i++) {
          Expression left = leftIt.next();
          Expression right = rightIt.next();
          VariableExpression tmpVar = new VariableExpression("$tmpVar$" + tmpVarCounter++);
          BinaryExpression bexp = new DeclarationExpression(tmpVar, bin.getOperation(), right);
          bexp.setSourcePosition(right);
          tmpAssignments.add(bexp);
          bexp = new BinaryExpression(left, bin.getOperation(), new VariableExpression(tmpVar));
          bexp.setSourcePosition(left);
          finalAssignments.add(bexp);
        }
        for (Expression tmpAssignment : tmpAssignments) {
          cle.addExpression(tmpAssignment);
        }
        for (Expression finalAssignment : finalAssignments) {
          cle.addExpression(finalAssignment);
        }
      }
      return staticCompilationTransformer.transform(cle);
    }
    return staticCompilationTransformer.superTransform(bin);
  }