@Override
 public Void visit(ObjectCreationExpr expr, AElement elem) {
   ClassOrInterfaceType type = expr.getType();
   AClass clazz = scene.classes.vivify(type.getName());
   Expression scope = expr.getScope();
   List<Type> typeArgs = expr.getTypeArgs();
   List<Expression> args = expr.getArgs();
   List<BodyDeclaration> decls = expr.getAnonymousClassBody();
   if (scope != null) {
     scope.accept(this, elem);
   }
   if (args != null) {
     for (Expression arg : args) {
       arg.accept(this, elem);
     }
   }
   if (typeArgs != null) {
     for (Type typeArg : typeArgs) {
       typeArg.accept(this, elem);
     }
   }
   type.accept(this, clazz);
   if (decls != null) {
     for (BodyDeclaration decl : decls) {
       decl.accept(this, clazz);
     }
   }
   return null;
 }
예제 #2
0
 /**
  * Print a list of type arguments in between angle brackets.
  *
  * @param args type arguments
  * @param arg argument provided to the calling visitor method
  */
 private void printTypeArgs(List<Type> args, Object arg) {
   if (args != null) {
     printer.print("<");
     for (Iterator<Type> i = args.iterator(); i.hasNext(); ) {
       Type t = i.next();
       t.accept(this, arg);
       if (i.hasNext()) {
         printer.print(", ");
       }
     }
     printer.print(">");
   }
 }
 /** Copies information from an AST type node to an {@link ATypeElement}. */
 private Void visitType(Type type, final ATypeElement elem) {
   List<AnnotationExpr> exprs = type.getAnnotations();
   if (exprs != null) {
     for (AnnotationExpr expr : exprs) {
       Annotation anno = extractAnnotation(expr);
       if (anno != null) {
         elem.tlAnnotationsHere.add(anno);
       }
     }
   }
   visitInnerTypes(type, elem);
   return null;
 }
  /**
   * Computes a type's "binary name".
   *
   * @param type the type
   * @return the type's binary name
   */
  private String getJVML(Type type) {
    return type.accept(
        new GenericVisitorAdapter<String, Void>() {
          @Override
          public String visit(ClassOrInterfaceType type, Void v) {
            String typeName = type.getName();
            String name = resolve(typeName);
            if (name != null) {
              String[] parts = name.split("\\.");
              StringBuilder sb = new StringBuilder("L").append(parts[0]);
              for (int i = 1; i < parts.length; i++) {
                sb.append('/').append(parts[i]);
              }
              sb.append(";");
              return sb.toString();
            }
            return "L" + typeName + ";";
          }

          @Override
          public String visit(PrimitiveType type, Void v) {
            switch (type.getType()) {
              case Boolean:
                return "Z";
              case Byte:
                return "B";
              case Char:
                return "C";
              case Double:
                return "D";
              case Float:
                return "F";
              case Int:
                return "I";
              case Long:
                return "J";
              case Short:
                return "S";
              default:
                throw new IllegalArgumentException(
                    "baseTypeName(): unknown primitive type " + type);
            }
          }

          @Override
          public String visit(ReferenceType type, Void v) {
            String typeName = type.getType().accept(this, null);
            StringBuilder sb = new StringBuilder();
            int n = type.getArrayCount();
            while (--n >= 0) {
              sb.append("[");
            }
            sb.append(typeName);
            return sb.toString();
          }

          @Override
          public String visit(VoidType type, Void v) {
            return "V";
          }

          @Override
          public String visit(WildcardType type, Void v) {
            return "Ljava/lang/Object;";
          }
        },
        null);
  }
  /** Copies information from an AST type node's inner type nodes to an {@link ATypeElement}. */
  private static Void visitInnerTypes(Type type, final ATypeElement elem) {
    return type.accept(
        new GenericVisitorAdapter<Void, InnerTypeLocation>() {
          @Override
          public Void visit(ClassOrInterfaceType type, InnerTypeLocation loc) {
            int i = 0;
            for (Type inner : type.getTypeArgs()) {
              InnerTypeLocation ext = extendedTypePath(loc, 3, i++);
              visitInnerType(inner, ext);
            }
            return null;
          }

          @Override
          public Void visit(ReferenceType type, InnerTypeLocation loc) {
            InnerTypeLocation ext = loc;
            int n = type.getArrayCount();
            for (int i = 0; i < n; i++) {
              ext = extendedTypePath(ext, 1, 0);
              for (AnnotationExpr expr : type.getAnnotationsAtLevel(i)) {
                ATypeElement typeElem = elem.innerTypes.vivify(ext);
                Annotation anno = extractAnnotation(expr);
                typeElem.tlAnnotationsHere.add(anno);
              }
            }
            return null;
          }

          @Override
          public Void visit(WildcardType type, InnerTypeLocation loc) {
            ReferenceType lower = type.getExtends();
            ReferenceType upper = type.getSuper();
            if (lower != null) {
              InnerTypeLocation ext = extendedTypePath(loc, 2, 0);
              visitInnerType(lower, ext);
            }
            if (upper != null) {
              InnerTypeLocation ext = extendedTypePath(loc, 2, 0);
              visitInnerType(upper, ext);
            }
            return null;
          }

          /** Copies information from an AST inner type node to an {@link ATypeElement}. */
          private void visitInnerType(Type type, InnerTypeLocation loc) {
            ATypeElement typeElem = elem.innerTypes.vivify(loc);
            for (AnnotationExpr expr : type.getAnnotations()) {
              Annotation anno = extractAnnotation(expr);
              typeElem.tlAnnotationsHere.add(anno);
              type.accept(this, loc);
            }
          }

          /**
           * Extends type path by one element.
           *
           * @see TypePathEntry.fromBinary
           */
          private InnerTypeLocation extendedTypePath(InnerTypeLocation loc, int tag, int arg) {
            List<TypePathEntry> path = new ArrayList<TypePathEntry>(loc.location.size() + 1);
            path.addAll(loc.location);
            path.add(TypePathEntry.fromBinary(tag, arg));
            return new InnerTypeLocation(path);
          }
        },
        InnerTypeLocation.EMPTY_INNER_TYPE_LOCATION);
  }