Example usage for org.eclipse.jdt.core.dom AST resolveWellKnownType

Introduction

In this page you can find the example usage for org.eclipse.jdt.core.dom AST resolveWellKnownType.

Prototype

public ITypeBinding resolveWellKnownType(String name) 

Source Link

Document

Returns the type binding for a "well known" type.

Usage

From source file:astview.WellKnownTypesProperty.java

License:Open Source License

@Override
public Object[] getChildren() {
    AST ast = fRoot.getAST();

    Binding[] res = new Binding[WELL_KNOWN_TYPES.length];
    for (int i = 0; i < WELL_KNOWN_TYPES.length; i++) {
        String type = WELL_KNOWN_TYPES[i];
        res[i] = new Binding(this, type, ast.resolveWellKnownType(type), true);
    }/*from w ww  .j  ava 2s  .  c  o m*/
    return res;
}

---

From source file:ca.ecliptical.pde.internal.ds.AnnotationProcessor.java

License:Open Source License

private ITypeBinding getObjectType(AST ast, ITypeBinding primitive) {
    if (Boolean.TYPE.getName().equals(primitive.getName()))
        return ast.resolveWellKnownType(Boolean.class.getName());

    if (Byte.TYPE.getName().equals(primitive.getName()))
        return ast.resolveWellKnownType(Byte.class.getName());

    if (Character.TYPE.getName().equals(primitive.getName()))
        return ast.resolveWellKnownType(Character.class.getName());

    if (Double.TYPE.getName().equals(primitive.getName()))
        return ast.resolveWellKnownType(Double.class.getName());

    if (Float.TYPE.getName().equals(primitive.getName()))
        return ast.resolveWellKnownType(Float.class.getName());

    if (Integer.TYPE.getName().equals(primitive.getName()))
        return ast.resolveWellKnownType(Integer.class.getName());

    if (Long.TYPE.getName().equals(primitive.getName()))
        return ast.resolveWellKnownType(Long.class.getName());

    if (Short.TYPE.getName().equals(primitive.getName()))
        return ast.resolveWellKnownType(Short.class.getName());

    return null;//from w  w w .j  a  v  a2  s  .  c o  m
}

---

From source file:cideplus.ui.astview.WellKnownTypesProperty.java

License:Open Source License

public Object[] getChildren() {
    AST ast = fRoot.getAST();

    Binding[] res = new Binding[WELL_KNOWN_TYPES.length];
    for (int i = 0; i < WELL_KNOWN_TYPES.length; i++) {
        String type = WELL_KNOWN_TYPES[i];
        res[i] = new Binding(this, type, ast.resolveWellKnownType(type), true);
    }//from  ww  w. j  a va 2s  .  co  m
    return res;
}

---

From source file:com.google.devtools.j2cpp.gen.CppStatementGenerator.java

License:Open Source License

private String getRightShiftType(Expression node) {
    ITypeBinding binding = node.resolveTypeBinding();
    AST ast = node.getAST();
    if (binding == null || ast.resolveWellKnownType("int").equals(binding)) {
        return "int";
    } else if (ast.resolveWellKnownType("long").equals(binding)) {
        return "long long";
    } else if (ast.resolveWellKnownType("byte").equals(binding)) {
        return "char";
    } else if (ast.resolveWellKnownType("short").equals(binding)) {
        return "short";
    } else if (ast.resolveWellKnownType("char").equals(binding)) {
        return "unichar";
    } else {/*w  w w  .j  a v a 2s  .  c o  m*/
        throw new AssertionError("invalid right shift expression type: " + binding.getName());
    }
}

---

From source file:com.google.devtools.j2cpp.translate.AnonymousClassConverter.java

License:Open Source License

/**
 * Adds val$N instance fields to type so references to external
 * variables can be resolved.  Existing constructors are updated to
 * initialize these fields; if no constructor exists, one is added.
 *///from  w  w w. j  ava2  s.co m
private GeneratedMethodBinding addInnerVars(TypeDeclaration node, List<IVariableBinding> innerVars,
        List<ReferenceDescription> references, List<Expression> invocationArguments) {
    @SuppressWarnings("unchecked")
    List<BodyDeclaration> members = node.bodyDeclarations(); // safe by definition
    List<IVariableBinding> innerFields = Lists.newArrayList();
    AST ast = node.getAST();
    ITypeBinding clazz = Types.getTypeBinding(node);

    for (IVariableBinding var : innerVars) {
        if (!isConstant(var)) { // Constants are in-lined instead.
            ITypeBinding varType = var.getDeclaringClass();
            if (varType == null) {
                varType = var.getType();
            }
            if (Types.hasIOSEquivalent(varType)) {
                varType = Types.mapType(varType);
            }
            String fieldName = "val$" + var.getName();
            FieldDeclaration field = createField(fieldName, varType, clazz, ast);
            members.add(field);
            IVariableBinding fieldVar = Types.getVariableBinding(field.fragments().get(0));
            innerFields.add(fieldVar);
            for (ReferenceDescription ref : references) {
                if (ref.binding == var && ref.innerField == null) {
                    ref.innerField = fieldVar;
                }
            }
        }
    }

    // Insert new parameters into constructor, if one was added by the
    // InitializationNormalizer from initializer blocks.
    boolean needsConstructor = true;
    GeneratedMethodBinding defaultConstructor = null;
    List<MethodDeclaration> enumConstructors = Lists.newArrayList();
    ITypeBinding enclosingClass = clazz.getDeclaringClass();
    for (BodyDeclaration member : members) {
        if (member instanceof MethodDeclaration && ((MethodDeclaration) member).isConstructor()) {
            if (argsMatch(invocationArguments, Types.getMethodBinding(member).getParameterTypes())) {
                MethodDeclaration constructor = (MethodDeclaration) member;
                needsConstructor = false;
                IMethodBinding oldBinding = Types.getMethodBinding(constructor);
                GeneratedMethodBinding newBinding = new GeneratedMethodBinding(oldBinding);
                Types.addBinding(constructor, newBinding);
                addInnerParameters(constructor, newBinding, innerFields, ast, true);
                defaultConstructor = newBinding;
                Symbols.scanAST(constructor);
                assert constructor.parameters().size() == defaultConstructor.getParameterTypes().length;
            }
            if (enclosingClass.isEnum()) {
                enumConstructors.add((MethodDeclaration) member);
            }
        }
    }

    if (!enumConstructors.isEmpty()) {
        for (MethodDeclaration constructor : enumConstructors) {
            GeneratedMethodBinding binding = new GeneratedMethodBinding(Types.getMethodBinding(constructor));
            if (!invocationArguments.isEmpty()) {
                // Remove super invocation added by InitializationNormalizer.
                @SuppressWarnings("unchecked")
                List<Statement> stmts = constructor.getBody().statements(); // safe by definition
                for (int i = 0; i < stmts.size(); i++) {
                    if (stmts.get(i) instanceof SuperConstructorInvocation) {
                        stmts.remove(i);
                        break;
                    }
                }

                // Update the binding to include the arguments,
                addArguments(invocationArguments, ast, clazz, constructor, binding);
                addInnerParameters(constructor, binding, innerFields, ast, true);
                Symbols.scanAST(constructor);
                Types.addBinding(constructor, binding);
            } else {
                defaultConstructor = binding;
            }
        }
        if (defaultConstructor == null) {
            defaultConstructor = new GeneratedMethodBinding(Types.getMethodBinding(enumConstructors.get(0)));
        }
    } else if (needsConstructor) {
        MethodDeclaration constructor = ast.newMethodDeclaration();
        constructor.setConstructor(true);
        ITypeBinding voidType = ast.resolveWellKnownType("void");
        GeneratedMethodBinding binding = new GeneratedMethodBinding("init", 0, voidType, clazz, true, false,
                true);
        Types.addBinding(constructor, binding);
        Types.addBinding(constructor.getReturnType2(), voidType);
        SimpleName name = ast.newSimpleName("init");
        Types.addBinding(name, binding);
        constructor.setName(name);
        constructor.setBody(ast.newBlock());
        if (!invocationArguments.isEmpty()) {
            addArguments(invocationArguments, ast, clazz, constructor, binding);
        }
        addInnerParameters(constructor, binding, innerFields, ast, true);
        members.add(constructor);
        Symbols.scanAST(constructor);
        defaultConstructor = binding;
        assert constructor.parameters().size() == defaultConstructor.getParameterTypes().length;
    }

    assert defaultConstructor != null;
    return defaultConstructor;
}

---

From source file:com.google.devtools.j2cpp.translate.AnonymousClassConverter.java

License:Open Source License

/**
 * Returns a literal node for a specified constant value.
 *//*from w  w  w .  ja  v a 2 s .co m*/
private Expression makeLiteral(Object value, String typeName, AST ast) {
    Expression literal;
    if (value instanceof Boolean) {
        literal = ast.newBooleanLiteral((Boolean) value);
    } else if (value instanceof Character) {
        CharacterLiteral c = ast.newCharacterLiteral();
        c.setCharValue((Character) value);
        literal = c;
    } else if (value instanceof Number) {
        literal = ast.newNumberLiteral(value.toString());
    } else if (value instanceof String) {
        StringLiteral s = ast.newStringLiteral();
        s.setLiteralValue((String) value);
        literal = s;
    } else {
        throw new AssertionError("unknown constant type");
    }
    ITypeBinding type = ast.resolveWellKnownType(typeName);
    assert type != null : "unknown constant type";
    Types.addBinding(literal, type);
    return literal;
}

---

From source file:com.google.devtools.j2cpp.translate.DestructorGenerator.java

License:Open Source License

private MethodDeclaration buildFinalizeMethod(AST ast, ITypeBinding declaringClass,
        List<IVariableBinding> fields) {
    ITypeBinding voidType = Types.mapTypeName("void");
    GeneratedMethodBinding binding = new GeneratedMethodBinding(destructorName, Modifier.PUBLIC, voidType,
            declaringClass, false, false, true);
    MethodDeclaration method = ast.newMethodDeclaration();
    Types.addBinding(method, binding);
    method.setName(ast.newSimpleName(destructorName));
    Types.addBinding(method.getName(), binding);
    @SuppressWarnings("unchecked")
    List<Modifier> modifiers = method.modifiers();
    modifiers.add(ast.newModifier(ModifierKeyword.PUBLIC_KEYWORD));
    method.setBody(ast.newBlock());// w  ww .ja  va2s.c  o  m
    addReleaseStatements(method, fields);
    Type returnType = ast.newPrimitiveType(PrimitiveType.VOID);
    Types.addBinding(returnType, ast.resolveWellKnownType("void"));
    method.setReturnType2(returnType);
    return method;
}

---

From source file:com.google.devtools.j2cpp.translate.GwtConverter.java

License:Open Source License

@Override
public boolean visit(MethodInvocation node) {
    IMethodBinding method = Types.getMethodBinding(node);
    @SuppressWarnings("unchecked")
    List<Expression> args = node.arguments();
    if (method.getName().equals("create") && method.getDeclaringClass().getQualifiedName().equals(GWT_CLASS)
            && args.size() == 1) {
        // Convert GWT.create(Foo.class) to Foo.class.newInstance().
        AST ast = node.getAST();
        SimpleName name = ast.newSimpleName("newInstance");
        node.setName(name);/*  www  .  j ava 2  s.c om*/
        Expression clazz = NodeCopier.copySubtree(ast, args.get(0));
        args.remove(0);
        node.setExpression(clazz);
        GeneratedMethodBinding newBinding = new GeneratedMethodBinding("newInstance", 0,
                ast.resolveWellKnownType("java.lang.Object"), ast.resolveWellKnownType("java.lang.Class"),
                false, false, false);
        Types.addBinding(name, newBinding);
        Types.addBinding(node, newBinding);
    } else if (isGwtTest(node)) {
        J2ObjC.error(node, "GWT.isScript() detected in boolean expression, which is not supported");
    }
    return true;
}

---

From source file:com.google.devtools.j2cpp.translate.InitializationNormalizer.java

License:Open Source License

@SuppressWarnings("unchecked")
private void addMethod(String name, int modifiers, ITypeBinding type, List<Statement> initStatements,
        List<BodyDeclaration> members, AST ast, boolean isConstructor) {
    Block body = ast.newBlock();/*  www. j a  va2  s  .  co  m*/
    List<Statement> stmts = body.statements(); // safe by definition
    for (Statement stmt : initStatements) {
        Statement newStmt = NodeCopier.copySubtree(ast, stmt);
        stmts.add(newStmt);
    }
    MethodDeclaration method = ast.newMethodDeclaration();
    GeneratedMethodBinding binding = new GeneratedMethodBinding(name, modifiers, null, type, isConstructor,
            false, true);
    Types.addBinding(method, binding);
    Type returnType = ast.newPrimitiveType(PrimitiveType.VOID);
    Types.addBinding(returnType, ast.resolveWellKnownType("void"));
    method.setReturnType2(returnType);
    method.setBody(body);
    method.setConstructor(isConstructor);
    method.modifiers().addAll(ast.newModifiers(modifiers));
    SimpleName nameNode = NameTable.unsafeSimpleName(name, ast);
    Types.addBinding(nameNode, binding);
    method.setName(nameNode);
    members.add(method);
    Symbols.resolve(method, binding);
}

---

From source file:com.google.devtools.j2cpp.translate.InnerClassExtractor.java

License:Open Source License

private void addOuterFields(AbstractTypeDeclaration node) {
    @SuppressWarnings("unchecked")
    List<BodyDeclaration> members = node.bodyDeclarations(); // safe by definition
    AST ast = node.getAST();
    ITypeBinding clazz = Types.getTypeBinding(node);
    ITypeBinding outerClazz = clazz.getDeclaringClass();
    assert outerClazz != null;

    List<IVariableBinding> innerFields = Lists.newArrayList();
    // Ensure that the new outer field does not conflict with a field in a superclass.
    ITypeBinding superClazz = clazz.getSuperclass();
    ITypeBinding superDeclaringClazz = superClazz.getDeclaringClass();
    int suffix = 0;
    while (superClazz.getDeclaringClass() != null) {
        if (!Modifier.isStatic(superClazz.getModifiers())) {
            suffix++;//from w  ww  . j ava  2 s  .  com
        }
        superClazz = superClazz.getSuperclass();
    }
    String outerFieldName = "this$" + suffix;

    FieldDeclaration outerField = createField(outerFieldName, outerClazz, clazz, ast);
    members.add(0, outerField);
    IVariableBinding outerVar = Types.getVariableBinding(outerField.fragments().get(0));
    innerFields.add(outerVar);

    if (superDeclaringClazz != null && !Modifier.isStatic(clazz.getSuperclass().getModifiers())
            && !outerClazz.isAssignmentCompatible(superDeclaringClazz.getTypeDeclaration())) {
        // The super class is an inner class, and it's declaring class and the
        // current node's declaring class don't match, so we need another outer
        // var. This var is only a parameter, not a field, an it's name doesn't
        // matter because addInnerParameters will assign a different name to it
        // anyway.
        IVariableBinding secondOuterVar = new GeneratedVariableBinding("", Modifier.FINAL, superDeclaringClazz,
                false, true, superClazz, null);
        innerFields.add(secondOuterVar);
    }

    // Insert new parameters for each constructor in class.
    boolean needsConstructor = true;
    for (BodyDeclaration member : members) {
        if (member instanceof MethodDeclaration && ((MethodDeclaration) member).isConstructor()) {
            needsConstructor = false;
            MethodDeclaration constructor = (MethodDeclaration) member;
            IMethodBinding oldBinding = Types.getMethodBinding(constructor);
            GeneratedMethodBinding newBinding = new GeneratedMethodBinding(oldBinding);
            Types.addBinding(constructor, newBinding);
            addInnerParameters(constructor, newBinding, innerFields, ast, false);
            assert constructor.parameters().size() == newBinding.getParameterTypes().length;
        }
    }

    if (needsConstructor) {
        MethodDeclaration constructor = ast.newMethodDeclaration();
        constructor.setConstructor(true);
        ITypeBinding voidType = ast.resolveWellKnownType("void");
        GeneratedMethodBinding binding = new GeneratedMethodBinding("init", 0, voidType, clazz, true, false,
                true);
        Types.addBinding(constructor, binding);
        Types.addBinding(constructor.getReturnType2(), voidType);
        SimpleName name = ast.newSimpleName("init");
        Types.addBinding(name, binding);
        constructor.setName(name);
        constructor.setBody(ast.newBlock());
        addInnerParameters(constructor, binding, innerFields, ast, false);
        members.add(constructor);
        assert constructor.parameters().size() == binding.getParameterTypes().length;
    }
}

---

• «
• 1
• 2
• 3
• 4
• »