Example usage for org.eclipse.jdt.core.dom ASTNode THROW_STATEMENT

List of usage examples for org.eclipse.jdt.core.dom ASTNode THROW_STATEMENT

  1. HOME
  2. Java
  3. org.eclipse.jdt
  4. org.eclipse.jdt.core.dom.*
  5. ASTNode
  6. THROW_STATEMENT

Introduction

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

Prototype

int THROW_STATEMENT

To view the source code for org.eclipse.jdt.core.dom ASTNode THROW_STATEMENT.

Click Source Link

Document

Node type constant indicating a node of type ThrowStatement.

Usage

From source file:ca.uvic.chisel.diver.sequencediagrams.sc.java.editors.JavaSequenceContentProvider.java

License:Open Source License

public boolean isCall(Object message) {
    if (message instanceof JavaMessage) {
        ASTNode node = ((JavaMessage) message).getAST();
        switch (node.getNodeType()) {
        case ASTNode.RETURN_STATEMENT:
        case ASTNode.THROW_STATEMENT:
            return false;
        }//from  w ww .  j  a v a2  s . c o m
    }
    return true;
}

From source file:com.google.devtools.j2objc.ast.TreeConverter.java

License:Apache License

public static TreeNode convertInner(ASTNode jdtNode) {
    switch (jdtNode.getNodeType()) {
    case ASTNode.ANNOTATION_TYPE_DECLARATION:
        return new AnnotationTypeDeclaration((org.eclipse.jdt.core.dom.AnnotationTypeDeclaration) jdtNode);
    case ASTNode.ANNOTATION_TYPE_MEMBER_DECLARATION:
        return new AnnotationTypeMemberDeclaration(
                (org.eclipse.jdt.core.dom.AnnotationTypeMemberDeclaration) jdtNode);
    case ASTNode.ANONYMOUS_CLASS_DECLARATION:
        return new AnonymousClassDeclaration((org.eclipse.jdt.core.dom.AnonymousClassDeclaration) jdtNode);
    case ASTNode.ARRAY_ACCESS:
        return new ArrayAccess((org.eclipse.jdt.core.dom.ArrayAccess) jdtNode);
    case ASTNode.ARRAY_CREATION:
        return new ArrayCreation((org.eclipse.jdt.core.dom.ArrayCreation) jdtNode);
    case ASTNode.ARRAY_INITIALIZER:
        return new ArrayInitializer((org.eclipse.jdt.core.dom.ArrayInitializer) jdtNode);
    case ASTNode.ARRAY_TYPE:
        return new ArrayType((org.eclipse.jdt.core.dom.ArrayType) jdtNode);
    case ASTNode.ASSERT_STATEMENT:
        return new AssertStatement((org.eclipse.jdt.core.dom.AssertStatement) jdtNode);
    case ASTNode.ASSIGNMENT:
        return new Assignment((org.eclipse.jdt.core.dom.Assignment) jdtNode);
    case ASTNode.BLOCK:
        return new Block((org.eclipse.jdt.core.dom.Block) jdtNode);
    case ASTNode.BLOCK_COMMENT:
        return new BlockComment((org.eclipse.jdt.core.dom.BlockComment) jdtNode);
    case ASTNode.BOOLEAN_LITERAL:
        return new BooleanLiteral((org.eclipse.jdt.core.dom.BooleanLiteral) jdtNode);
    case ASTNode.BREAK_STATEMENT:
        return new BreakStatement((org.eclipse.jdt.core.dom.BreakStatement) jdtNode);
    case ASTNode.CAST_EXPRESSION:
        return new CastExpression((org.eclipse.jdt.core.dom.CastExpression) jdtNode);
    case ASTNode.CATCH_CLAUSE:
        return new CatchClause((org.eclipse.jdt.core.dom.CatchClause) jdtNode);
    case ASTNode.CHARACTER_LITERAL:
        return new CharacterLiteral((org.eclipse.jdt.core.dom.CharacterLiteral) jdtNode);
    case ASTNode.CLASS_INSTANCE_CREATION:
        return new ClassInstanceCreation((org.eclipse.jdt.core.dom.ClassInstanceCreation) jdtNode);
    case ASTNode.CONDITIONAL_EXPRESSION:
        return new ConditionalExpression((org.eclipse.jdt.core.dom.ConditionalExpression) jdtNode);
    case ASTNode.CONSTRUCTOR_INVOCATION:
        return new ConstructorInvocation((org.eclipse.jdt.core.dom.ConstructorInvocation) jdtNode);
    case ASTNode.CONTINUE_STATEMENT:
        return new ContinueStatement((org.eclipse.jdt.core.dom.ContinueStatement) jdtNode);
    case ASTNode.DO_STATEMENT:
        return new DoStatement((org.eclipse.jdt.core.dom.DoStatement) jdtNode);
    case ASTNode.EMPTY_STATEMENT:
        return new EmptyStatement((org.eclipse.jdt.core.dom.EmptyStatement) jdtNode);
    case ASTNode.ENHANCED_FOR_STATEMENT:
        return new EnhancedForStatement((org.eclipse.jdt.core.dom.EnhancedForStatement) jdtNode);
    case ASTNode.ENUM_CONSTANT_DECLARATION:
        return new EnumConstantDeclaration((org.eclipse.jdt.core.dom.EnumConstantDeclaration) jdtNode);
    case ASTNode.ENUM_DECLARATION:
        return new EnumDeclaration((org.eclipse.jdt.core.dom.EnumDeclaration) jdtNode);
    case ASTNode.EXPRESSION_STATEMENT:
        return new ExpressionStatement((org.eclipse.jdt.core.dom.ExpressionStatement) jdtNode);
    case ASTNode.FIELD_ACCESS:
        return new FieldAccess((org.eclipse.jdt.core.dom.FieldAccess) jdtNode);
    case ASTNode.FIELD_DECLARATION:
        return new FieldDeclaration((org.eclipse.jdt.core.dom.FieldDeclaration) jdtNode);
    case ASTNode.FOR_STATEMENT:
        return new ForStatement((org.eclipse.jdt.core.dom.ForStatement) jdtNode);
    case ASTNode.IF_STATEMENT:
        return new IfStatement((org.eclipse.jdt.core.dom.IfStatement) jdtNode);
    case ASTNode.INFIX_EXPRESSION:
        return new InfixExpression((org.eclipse.jdt.core.dom.InfixExpression) jdtNode);
    case ASTNode.INITIALIZER:
        return new Initializer((org.eclipse.jdt.core.dom.Initializer) jdtNode);
    case ASTNode.INSTANCEOF_EXPRESSION:
        return new InstanceofExpression((org.eclipse.jdt.core.dom.InstanceofExpression) jdtNode);
    case ASTNode.JAVADOC:
        return new Javadoc((org.eclipse.jdt.core.dom.Javadoc) jdtNode);
    case ASTNode.LABELED_STATEMENT:
        return new LabeledStatement((org.eclipse.jdt.core.dom.LabeledStatement) jdtNode);
    case ASTNode.LINE_COMMENT:
        return new LineComment((org.eclipse.jdt.core.dom.LineComment) jdtNode);
    case ASTNode.MARKER_ANNOTATION:
        return new MarkerAnnotation((org.eclipse.jdt.core.dom.MarkerAnnotation) jdtNode);
    case ASTNode.MEMBER_VALUE_PAIR:
        return new MemberValuePair((org.eclipse.jdt.core.dom.MemberValuePair) jdtNode);
    case ASTNode.METHOD_DECLARATION:
        return new MethodDeclaration((org.eclipse.jdt.core.dom.MethodDeclaration) jdtNode);
    case ASTNode.METHOD_INVOCATION:
        return new MethodInvocation((org.eclipse.jdt.core.dom.MethodInvocation) jdtNode);
    case ASTNode.NORMAL_ANNOTATION:
        return new NormalAnnotation((org.eclipse.jdt.core.dom.NormalAnnotation) jdtNode);
    case ASTNode.NULL_LITERAL:
        return new NullLiteral((org.eclipse.jdt.core.dom.NullLiteral) jdtNode);
    case ASTNode.NUMBER_LITERAL:
        return new NumberLiteral((org.eclipse.jdt.core.dom.NumberLiteral) jdtNode);
    case ASTNode.PACKAGE_DECLARATION:
        return new PackageDeclaration((org.eclipse.jdt.core.dom.PackageDeclaration) jdtNode);
    case ASTNode.PARAMETERIZED_TYPE:
        return new ParameterizedType((org.eclipse.jdt.core.dom.ParameterizedType) jdtNode);
    case ASTNode.PARENTHESIZED_EXPRESSION:
        return new ParenthesizedExpression((org.eclipse.jdt.core.dom.ParenthesizedExpression) jdtNode);
    case ASTNode.POSTFIX_EXPRESSION:
        return new PostfixExpression((org.eclipse.jdt.core.dom.PostfixExpression) jdtNode);
    case ASTNode.PREFIX_EXPRESSION:
        return new PrefixExpression((org.eclipse.jdt.core.dom.PrefixExpression) jdtNode);
    case ASTNode.PRIMITIVE_TYPE:
        return new PrimitiveType((org.eclipse.jdt.core.dom.PrimitiveType) jdtNode);
    case ASTNode.QUALIFIED_NAME:
        return new QualifiedName((org.eclipse.jdt.core.dom.QualifiedName) jdtNode);
    case ASTNode.QUALIFIED_TYPE:
        return new QualifiedType((org.eclipse.jdt.core.dom.QualifiedType) jdtNode);
    case ASTNode.RETURN_STATEMENT:
        return new ReturnStatement((org.eclipse.jdt.core.dom.ReturnStatement) jdtNode);
    case ASTNode.SIMPLE_NAME:
        return new SimpleName((org.eclipse.jdt.core.dom.SimpleName) jdtNode);
    case ASTNode.SIMPLE_TYPE:
        return new SimpleType((org.eclipse.jdt.core.dom.SimpleType) jdtNode);
    case ASTNode.SINGLE_MEMBER_ANNOTATION:
        return new SingleMemberAnnotation((org.eclipse.jdt.core.dom.SingleMemberAnnotation) jdtNode);
    case ASTNode.SINGLE_VARIABLE_DECLARATION:
        return new SingleVariableDeclaration((org.eclipse.jdt.core.dom.SingleVariableDeclaration) jdtNode);
    case ASTNode.STRING_LITERAL:
        return new StringLiteral((org.eclipse.jdt.core.dom.StringLiteral) jdtNode);
    case ASTNode.SUPER_CONSTRUCTOR_INVOCATION:
        return new SuperConstructorInvocation((org.eclipse.jdt.core.dom.SuperConstructorInvocation) jdtNode);
    case ASTNode.SUPER_FIELD_ACCESS:
        return new SuperFieldAccess((org.eclipse.jdt.core.dom.SuperFieldAccess) jdtNode);
    case ASTNode.SUPER_METHOD_INVOCATION:
        return new SuperMethodInvocation((org.eclipse.jdt.core.dom.SuperMethodInvocation) jdtNode);
    case ASTNode.SWITCH_CASE:
        return new SwitchCase((org.eclipse.jdt.core.dom.SwitchCase) jdtNode);
    case ASTNode.SWITCH_STATEMENT:
        return new SwitchStatement((org.eclipse.jdt.core.dom.SwitchStatement) jdtNode);
    case ASTNode.SYNCHRONIZED_STATEMENT:
        return new SynchronizedStatement((org.eclipse.jdt.core.dom.SynchronizedStatement) jdtNode);
    case ASTNode.TAG_ELEMENT:
        return new TagElement((org.eclipse.jdt.core.dom.TagElement) jdtNode);
    case ASTNode.TEXT_ELEMENT:
        return new TextElement((org.eclipse.jdt.core.dom.TextElement) jdtNode);
    case ASTNode.THIS_EXPRESSION:
        return new ThisExpression((org.eclipse.jdt.core.dom.ThisExpression) jdtNode);
    case ASTNode.THROW_STATEMENT:
        return new ThrowStatement((org.eclipse.jdt.core.dom.ThrowStatement) jdtNode);
    case ASTNode.TRY_STATEMENT:
        return new TryStatement((org.eclipse.jdt.core.dom.TryStatement) jdtNode);
    case ASTNode.TYPE_DECLARATION:
        return new TypeDeclaration((org.eclipse.jdt.core.dom.TypeDeclaration) jdtNode);
    case ASTNode.TYPE_DECLARATION_STATEMENT:
        return new TypeDeclarationStatement((org.eclipse.jdt.core.dom.TypeDeclarationStatement) jdtNode);
    case ASTNode.TYPE_LITERAL:
        return new TypeLiteral((org.eclipse.jdt.core.dom.TypeLiteral) jdtNode);
    case ASTNode.UNION_TYPE:
        return new UnionType((org.eclipse.jdt.core.dom.UnionType) jdtNode);
    case ASTNode.VARIABLE_DECLARATION_EXPRESSION:
        return new VariableDeclarationExpression(
                (org.eclipse.jdt.core.dom.VariableDeclarationExpression) jdtNode);
    case ASTNode.VARIABLE_DECLARATION_FRAGMENT:
        return new VariableDeclarationFragment((org.eclipse.jdt.core.dom.VariableDeclarationFragment) jdtNode);
    case ASTNode.VARIABLE_DECLARATION_STATEMENT:
        return new VariableDeclarationStatement(
                (org.eclipse.jdt.core.dom.VariableDeclarationStatement) jdtNode);
    case ASTNode.WHILE_STATEMENT:
        return new WhileStatement((org.eclipse.jdt.core.dom.WhileStatement) jdtNode);
    // These nodes only appear in comments and J2ObjC doens't need any
    // information from their subtree so we just convert them to TextElement.
    case ASTNode.MEMBER_REF:
    case ASTNode.METHOD_REF:
    case ASTNode.METHOD_REF_PARAMETER:
        return new TextElement(jdtNode);
    case ASTNode.COMPILATION_UNIT:
        throw new AssertionError("CompilationUnit must be converted using convertCompilationUnit()");
    default:/* w  w  w. ja  v a  2s .  c  o  m*/
        throw new AssertionError("Unknown node type: " + jdtNode.getClass().getName());
    }
}

From source file:com.google.devtools.j2objc.jdt.TreeConverter.java

License:Apache License

private static TreeNode convertInner(ASTNode jdtNode) {
    switch (jdtNode.getNodeType()) {
    case ASTNode.ANNOTATION_TYPE_DECLARATION:
        return convertAnnotationTypeDeclaration((org.eclipse.jdt.core.dom.AnnotationTypeDeclaration) jdtNode);
    case ASTNode.ANNOTATION_TYPE_MEMBER_DECLARATION:
        return convertAnnotationTypeMemberDeclaration(
                (org.eclipse.jdt.core.dom.AnnotationTypeMemberDeclaration) jdtNode);
    case ASTNode.ARRAY_ACCESS:
        return convertArrayAccess((org.eclipse.jdt.core.dom.ArrayAccess) jdtNode);
    case ASTNode.ARRAY_CREATION:
        return convertArrayCreation((org.eclipse.jdt.core.dom.ArrayCreation) jdtNode);
    case ASTNode.ARRAY_INITIALIZER:
        return convertArrayInitializer((org.eclipse.jdt.core.dom.ArrayInitializer) jdtNode);
    case ASTNode.ARRAY_TYPE:
        return convertArrayType((org.eclipse.jdt.core.dom.ArrayType) jdtNode);
    case ASTNode.ASSERT_STATEMENT:
        return convertAssertStatement((org.eclipse.jdt.core.dom.AssertStatement) jdtNode);
    case ASTNode.ASSIGNMENT:
        return convertAssignment((org.eclipse.jdt.core.dom.Assignment) jdtNode);
    case ASTNode.BLOCK:
        return convertBlock((org.eclipse.jdt.core.dom.Block) jdtNode);
    case ASTNode.BLOCK_COMMENT:
        return new BlockComment();
    case ASTNode.BOOLEAN_LITERAL:
        return convertBooleanLiteral((org.eclipse.jdt.core.dom.BooleanLiteral) jdtNode);
    case ASTNode.BREAK_STATEMENT:
        return convertBreakStatement((org.eclipse.jdt.core.dom.BreakStatement) jdtNode);
    case ASTNode.CAST_EXPRESSION:
        return convertCastExpression((org.eclipse.jdt.core.dom.CastExpression) jdtNode);
    case ASTNode.CATCH_CLAUSE:
        return convertCatchClause((org.eclipse.jdt.core.dom.CatchClause) jdtNode);
    case ASTNode.CHARACTER_LITERAL:
        return convertCharacterLiteral((org.eclipse.jdt.core.dom.CharacterLiteral) jdtNode);
    case ASTNode.CLASS_INSTANCE_CREATION:
        return convertClassInstanceCreation((org.eclipse.jdt.core.dom.ClassInstanceCreation) jdtNode);
    case ASTNode.CONDITIONAL_EXPRESSION:
        return convertConditionalExpression((org.eclipse.jdt.core.dom.ConditionalExpression) jdtNode);
    case ASTNode.CONSTRUCTOR_INVOCATION:
        return convertConstructorInvocation((org.eclipse.jdt.core.dom.ConstructorInvocation) jdtNode);
    case ASTNode.CONTINUE_STATEMENT:
        return convertContinueStatement((org.eclipse.jdt.core.dom.ContinueStatement) jdtNode);
    case ASTNode.CREATION_REFERENCE:
        return convertCreationReference((org.eclipse.jdt.core.dom.CreationReference) jdtNode);
    case ASTNode.DIMENSION:
        return convertDimension((org.eclipse.jdt.core.dom.Dimension) jdtNode);
    case ASTNode.DO_STATEMENT:
        return convertDoStatement((org.eclipse.jdt.core.dom.DoStatement) jdtNode);
    case ASTNode.EMPTY_STATEMENT:
        return new EmptyStatement();
    case ASTNode.ENHANCED_FOR_STATEMENT:
        return convertEnhancedForStatement((org.eclipse.jdt.core.dom.EnhancedForStatement) jdtNode);
    case ASTNode.ENUM_CONSTANT_DECLARATION:
        return convertEnumConstantDeclaration((org.eclipse.jdt.core.dom.EnumConstantDeclaration) jdtNode);
    case ASTNode.ENUM_DECLARATION:
        return convertEnumDeclaration((org.eclipse.jdt.core.dom.EnumDeclaration) jdtNode);
    case ASTNode.EXPRESSION_METHOD_REFERENCE:
        return convertExpressionMethodReference((org.eclipse.jdt.core.dom.ExpressionMethodReference) jdtNode);
    case ASTNode.EXPRESSION_STATEMENT:
        return convertExpressionStatement((org.eclipse.jdt.core.dom.ExpressionStatement) jdtNode);
    case ASTNode.FIELD_ACCESS:
        return convertFieldAccess((org.eclipse.jdt.core.dom.FieldAccess) jdtNode);
    case ASTNode.FIELD_DECLARATION:
        return convertFieldDeclaration((org.eclipse.jdt.core.dom.FieldDeclaration) jdtNode);
    case ASTNode.FOR_STATEMENT:
        return convertForStatement((org.eclipse.jdt.core.dom.ForStatement) jdtNode);
    case ASTNode.IF_STATEMENT:
        return convertIfStatement((org.eclipse.jdt.core.dom.IfStatement) jdtNode);
    case ASTNode.INFIX_EXPRESSION:
        return convertInfixExpression((org.eclipse.jdt.core.dom.InfixExpression) jdtNode);
    case ASTNode.INTERSECTION_TYPE:
        return convertIntersectionType((org.eclipse.jdt.core.dom.IntersectionType) jdtNode);
    case ASTNode.INITIALIZER:
        return convertInitializer((org.eclipse.jdt.core.dom.Initializer) jdtNode);
    case ASTNode.INSTANCEOF_EXPRESSION:
        return convertInstanceofExpression((org.eclipse.jdt.core.dom.InstanceofExpression) jdtNode);
    case ASTNode.JAVADOC:
        return convertJavadoc((org.eclipse.jdt.core.dom.Javadoc) jdtNode);
    case ASTNode.LABELED_STATEMENT:
        return convertLabeledStatement((org.eclipse.jdt.core.dom.LabeledStatement) jdtNode);
    case ASTNode.LAMBDA_EXPRESSION:
        return convertLambdaExpression((org.eclipse.jdt.core.dom.LambdaExpression) jdtNode);
    case ASTNode.LINE_COMMENT:
        return new LineComment();
    case ASTNode.MARKER_ANNOTATION:
        return convertMarkerAnnotation((org.eclipse.jdt.core.dom.MarkerAnnotation) jdtNode);
    case ASTNode.MEMBER_VALUE_PAIR:
        return convertMemberValuePair((org.eclipse.jdt.core.dom.MemberValuePair) jdtNode);
    case ASTNode.METHOD_DECLARATION:
        return convertMethodDeclaration((org.eclipse.jdt.core.dom.MethodDeclaration) jdtNode);
    case ASTNode.METHOD_INVOCATION:
        return convertMethodInvocation((org.eclipse.jdt.core.dom.MethodInvocation) jdtNode);
    case ASTNode.NAME_QUALIFIED_TYPE:
        return convertNameQualifiedType((org.eclipse.jdt.core.dom.NameQualifiedType) jdtNode);
    case ASTNode.NORMAL_ANNOTATION:
        return convertNormalAnnotation((org.eclipse.jdt.core.dom.NormalAnnotation) jdtNode);
    case ASTNode.NULL_LITERAL:
        return new NullLiteral(BindingConverter.NULL_TYPE);
    case ASTNode.NUMBER_LITERAL:
        return convertNumberLiteral((org.eclipse.jdt.core.dom.NumberLiteral) jdtNode);
    case ASTNode.PACKAGE_DECLARATION:
        return convertPackageDeclaration((org.eclipse.jdt.core.dom.PackageDeclaration) jdtNode);
    case ASTNode.PARAMETERIZED_TYPE:
        return convertParameterizedType((org.eclipse.jdt.core.dom.ParameterizedType) jdtNode);
    case ASTNode.PARENTHESIZED_EXPRESSION:
        return convertParenthesizedExpression((org.eclipse.jdt.core.dom.ParenthesizedExpression) jdtNode);
    case ASTNode.POSTFIX_EXPRESSION:
        return convertPostfixExpression((org.eclipse.jdt.core.dom.PostfixExpression) jdtNode);
    case ASTNode.PREFIX_EXPRESSION:
        return convertPrefixExpression((org.eclipse.jdt.core.dom.PrefixExpression) jdtNode);
    case ASTNode.PRIMITIVE_TYPE:
        return convertPrimitiveType((org.eclipse.jdt.core.dom.PrimitiveType) jdtNode);
    case ASTNode.QUALIFIED_NAME:
        return convertQualifiedName((org.eclipse.jdt.core.dom.QualifiedName) jdtNode);
    case ASTNode.QUALIFIED_TYPE:
        return convertQualifiedType((org.eclipse.jdt.core.dom.QualifiedType) jdtNode);
    case ASTNode.RETURN_STATEMENT:
        return convertReturnStatement((org.eclipse.jdt.core.dom.ReturnStatement) jdtNode);
    case ASTNode.SIMPLE_NAME:
        return convertSimpleName((org.eclipse.jdt.core.dom.SimpleName) jdtNode);
    case ASTNode.SIMPLE_TYPE:
        return convertSimpleType((org.eclipse.jdt.core.dom.SimpleType) jdtNode);
    case ASTNode.SINGLE_MEMBER_ANNOTATION:
        return convertSingleMemberAnnotation((org.eclipse.jdt.core.dom.SingleMemberAnnotation) jdtNode);
    case ASTNode.SINGLE_VARIABLE_DECLARATION:
        return convertSingleVariableDeclaration((org.eclipse.jdt.core.dom.SingleVariableDeclaration) jdtNode);
    case ASTNode.STRING_LITERAL:
        return convertStringLiteral((org.eclipse.jdt.core.dom.StringLiteral) jdtNode);
    case ASTNode.SUPER_CONSTRUCTOR_INVOCATION:
        return convertSuperConstructorInvocation((org.eclipse.jdt.core.dom.SuperConstructorInvocation) jdtNode);
    case ASTNode.SUPER_FIELD_ACCESS:
        return convertSuperFieldAccess((org.eclipse.jdt.core.dom.SuperFieldAccess) jdtNode);
    case ASTNode.SUPER_METHOD_INVOCATION:
        return convertSuperMethodInvocation((org.eclipse.jdt.core.dom.SuperMethodInvocation) jdtNode);
    case ASTNode.SUPER_METHOD_REFERENCE:
        return convertSuperMethodReference((org.eclipse.jdt.core.dom.SuperMethodReference) jdtNode);
    case ASTNode.SWITCH_CASE:
        return convertSwitchCase((org.eclipse.jdt.core.dom.SwitchCase) jdtNode);
    case ASTNode.SWITCH_STATEMENT:
        return convertSwitchStatement((org.eclipse.jdt.core.dom.SwitchStatement) jdtNode);
    case ASTNode.SYNCHRONIZED_STATEMENT:
        return convertSynchronizedStatement((org.eclipse.jdt.core.dom.SynchronizedStatement) jdtNode);
    case ASTNode.TAG_ELEMENT:
        return convertTagElement((org.eclipse.jdt.core.dom.TagElement) jdtNode);
    case ASTNode.TEXT_ELEMENT:
        return convertTextElement(((org.eclipse.jdt.core.dom.TextElement) jdtNode).getText());
    case ASTNode.THIS_EXPRESSION:
        return convertThisExpression((org.eclipse.jdt.core.dom.ThisExpression) jdtNode);
    case ASTNode.THROW_STATEMENT:
        return convertThrowStatement((org.eclipse.jdt.core.dom.ThrowStatement) jdtNode);
    case ASTNode.TRY_STATEMENT:
        return convertTryStatement((org.eclipse.jdt.core.dom.TryStatement) jdtNode);
    case ASTNode.TYPE_DECLARATION:
        return convertTypeDeclaration((org.eclipse.jdt.core.dom.TypeDeclaration) jdtNode);
    case ASTNode.TYPE_DECLARATION_STATEMENT:
        return convertTypeDeclarationStatement((org.eclipse.jdt.core.dom.TypeDeclarationStatement) jdtNode);
    case ASTNode.TYPE_LITERAL:
        return convertTypeLiteral((org.eclipse.jdt.core.dom.TypeLiteral) jdtNode);
    case ASTNode.TYPE_METHOD_REFERENCE:
        return convertTypeMethodReference((org.eclipse.jdt.core.dom.TypeMethodReference) jdtNode);
    case ASTNode.UNION_TYPE:
        return convertUnionType((org.eclipse.jdt.core.dom.UnionType) jdtNode);
    case ASTNode.VARIABLE_DECLARATION_EXPRESSION:
        return convertVariableDeclarationExpression(
                (org.eclipse.jdt.core.dom.VariableDeclarationExpression) jdtNode);
    case ASTNode.VARIABLE_DECLARATION_FRAGMENT:
        return convertVariableDeclarationFragment(
                (org.eclipse.jdt.core.dom.VariableDeclarationFragment) jdtNode);
    case ASTNode.VARIABLE_DECLARATION_STATEMENT:
        return convertVariableDeclarationStatement(
                (org.eclipse.jdt.core.dom.VariableDeclarationStatement) jdtNode);
    case ASTNode.WHILE_STATEMENT:
        return convertWhileStatement((org.eclipse.jdt.core.dom.WhileStatement) jdtNode);
    // These nodes only appear in comments and J2ObjC doens't need any
    // information from their subtree so we just convert them to TextElement.
    case ASTNode.MEMBER_REF:
    case ASTNode.METHOD_REF:
    case ASTNode.METHOD_REF_PARAMETER:
        return convertTextElement(jdtNode.toString());
    case ASTNode.COMPILATION_UNIT:
        throw new AssertionError("CompilationUnit must be converted using convertCompilationUnit()");
    default://w  ww  .  j  av  a  2s. co m
        throw new AssertionError("Unknown node type: " + jdtNode.getClass().getName());
    }
}

From source file:com.j2swift.ast.TreeConverter.java

License:Apache License

public static TreeNode convertInner(ASTNode jdtNode) {
    switch (jdtNode.getNodeType()) {
    case ASTNode.ANNOTATION_TYPE_DECLARATION:
        return new AnnotationTypeDeclaration((org.eclipse.jdt.core.dom.AnnotationTypeDeclaration) jdtNode);
    case ASTNode.ANNOTATION_TYPE_MEMBER_DECLARATION:
        return new AnnotationTypeMemberDeclaration(
                (org.eclipse.jdt.core.dom.AnnotationTypeMemberDeclaration) jdtNode);
    case ASTNode.ANONYMOUS_CLASS_DECLARATION:
        return new AnonymousClassDeclaration((org.eclipse.jdt.core.dom.AnonymousClassDeclaration) jdtNode);
    case ASTNode.ARRAY_ACCESS:
        return new ArrayAccess((org.eclipse.jdt.core.dom.ArrayAccess) jdtNode);
    case ASTNode.ARRAY_CREATION:
        return new ArrayCreation((org.eclipse.jdt.core.dom.ArrayCreation) jdtNode);
    case ASTNode.ARRAY_INITIALIZER:
        return new ArrayInitializer((org.eclipse.jdt.core.dom.ArrayInitializer) jdtNode);
    case ASTNode.ARRAY_TYPE:
        return new ArrayType((org.eclipse.jdt.core.dom.ArrayType) jdtNode);
    case ASTNode.ASSERT_STATEMENT:
        return new AssertStatement((org.eclipse.jdt.core.dom.AssertStatement) jdtNode);
    case ASTNode.ASSIGNMENT:
        return new Assignment((org.eclipse.jdt.core.dom.Assignment) jdtNode);
    case ASTNode.BLOCK:
        return new Block((org.eclipse.jdt.core.dom.Block) jdtNode);
    case ASTNode.BLOCK_COMMENT:
        return new BlockComment((org.eclipse.jdt.core.dom.BlockComment) jdtNode);
    case ASTNode.BOOLEAN_LITERAL:
        return new BooleanLiteral((org.eclipse.jdt.core.dom.BooleanLiteral) jdtNode);
    case ASTNode.BREAK_STATEMENT:
        return new BreakStatement((org.eclipse.jdt.core.dom.BreakStatement) jdtNode);
    case ASTNode.CAST_EXPRESSION:
        return new CastExpression((org.eclipse.jdt.core.dom.CastExpression) jdtNode);
    case ASTNode.CATCH_CLAUSE:
        return new CatchClause((org.eclipse.jdt.core.dom.CatchClause) jdtNode);
    case ASTNode.CHARACTER_LITERAL:
        return new CharacterLiteral((org.eclipse.jdt.core.dom.CharacterLiteral) jdtNode);
    case ASTNode.CLASS_INSTANCE_CREATION:
        return new ClassInstanceCreation((org.eclipse.jdt.core.dom.ClassInstanceCreation) jdtNode);
    case ASTNode.CONDITIONAL_EXPRESSION:
        return new ConditionalExpression((org.eclipse.jdt.core.dom.ConditionalExpression) jdtNode);
    case ASTNode.CONSTRUCTOR_INVOCATION:
        return new ConstructorInvocation((org.eclipse.jdt.core.dom.ConstructorInvocation) jdtNode);
    case ASTNode.CONTINUE_STATEMENT:
        return new ContinueStatement((org.eclipse.jdt.core.dom.ContinueStatement) jdtNode);
    case ASTNode.CREATION_REFERENCE:
        return new CreationReference((org.eclipse.jdt.core.dom.CreationReference) jdtNode);
    case ASTNode.DIMENSION:
        return new Dimension((org.eclipse.jdt.core.dom.Dimension) jdtNode);
    case ASTNode.DO_STATEMENT:
        return new DoStatement((org.eclipse.jdt.core.dom.DoStatement) jdtNode);
    case ASTNode.EMPTY_STATEMENT:
        return new EmptyStatement((org.eclipse.jdt.core.dom.EmptyStatement) jdtNode);
    case ASTNode.ENHANCED_FOR_STATEMENT:
        return new EnhancedForStatement((org.eclipse.jdt.core.dom.EnhancedForStatement) jdtNode);
    case ASTNode.ENUM_CONSTANT_DECLARATION:
        return new EnumConstantDeclaration((org.eclipse.jdt.core.dom.EnumConstantDeclaration) jdtNode);
    case ASTNode.ENUM_DECLARATION:
        return new EnumDeclaration((org.eclipse.jdt.core.dom.EnumDeclaration) jdtNode);
    case ASTNode.EXPRESSION_METHOD_REFERENCE:
        return new ExpressionMethodReference((org.eclipse.jdt.core.dom.ExpressionMethodReference) jdtNode);
    case ASTNode.EXPRESSION_STATEMENT:
        return new ExpressionStatement((org.eclipse.jdt.core.dom.ExpressionStatement) jdtNode);
    case ASTNode.FIELD_ACCESS:
        return new FieldAccess((org.eclipse.jdt.core.dom.FieldAccess) jdtNode);
    case ASTNode.FIELD_DECLARATION:
        return new FieldDeclaration((org.eclipse.jdt.core.dom.FieldDeclaration) jdtNode);
    case ASTNode.FOR_STATEMENT:
        return new ForStatement((org.eclipse.jdt.core.dom.ForStatement) jdtNode);
    case ASTNode.IF_STATEMENT:
        return new IfStatement((org.eclipse.jdt.core.dom.IfStatement) jdtNode);
    case ASTNode.INFIX_EXPRESSION:
        return new InfixExpression((org.eclipse.jdt.core.dom.InfixExpression) jdtNode);
    case ASTNode.INTERSECTION_TYPE:
        return new IntersectionType((org.eclipse.jdt.core.dom.IntersectionType) jdtNode);
    case ASTNode.INITIALIZER:
        return new Initializer((org.eclipse.jdt.core.dom.Initializer) jdtNode);
    case ASTNode.INSTANCEOF_EXPRESSION:
        return new InstanceofExpression((org.eclipse.jdt.core.dom.InstanceofExpression) jdtNode);
    case ASTNode.JAVADOC:
        return new Javadoc((org.eclipse.jdt.core.dom.Javadoc) jdtNode);
    case ASTNode.LABELED_STATEMENT:
        return new LabeledStatement((org.eclipse.jdt.core.dom.LabeledStatement) jdtNode);
    case ASTNode.LAMBDA_EXPRESSION:
        return new LambdaExpression((org.eclipse.jdt.core.dom.LambdaExpression) jdtNode);
    case ASTNode.LINE_COMMENT:
        return new LineComment((org.eclipse.jdt.core.dom.LineComment) jdtNode);
    case ASTNode.MARKER_ANNOTATION:
        return MarkerAnnotation.convert((org.eclipse.jdt.core.dom.MarkerAnnotation) jdtNode);
    case ASTNode.MEMBER_VALUE_PAIR:
        return new MemberValuePair((org.eclipse.jdt.core.dom.MemberValuePair) jdtNode);
    case ASTNode.METHOD_DECLARATION:
        return new MethodDeclaration((org.eclipse.jdt.core.dom.MethodDeclaration) jdtNode);
    case ASTNode.METHOD_INVOCATION:
        return new MethodInvocation((org.eclipse.jdt.core.dom.MethodInvocation) jdtNode);
    case ASTNode.NAME_QUALIFIED_TYPE:
        return new NameQualifiedType((org.eclipse.jdt.core.dom.NameQualifiedType) jdtNode);
    case ASTNode.NORMAL_ANNOTATION:
        return new NormalAnnotation((org.eclipse.jdt.core.dom.NormalAnnotation) jdtNode);
    case ASTNode.NULL_LITERAL:
        return new NullLiteral((org.eclipse.jdt.core.dom.NullLiteral) jdtNode);
    case ASTNode.NUMBER_LITERAL:
        return new NumberLiteral((org.eclipse.jdt.core.dom.NumberLiteral) jdtNode);
    case ASTNode.PACKAGE_DECLARATION:
        return new PackageDeclaration((org.eclipse.jdt.core.dom.PackageDeclaration) jdtNode);
    case ASTNode.PARAMETERIZED_TYPE:
        return new ParameterizedType((org.eclipse.jdt.core.dom.ParameterizedType) jdtNode);
    case ASTNode.PARENTHESIZED_EXPRESSION:
        return new ParenthesizedExpression((org.eclipse.jdt.core.dom.ParenthesizedExpression) jdtNode);
    case ASTNode.POSTFIX_EXPRESSION:
        return new PostfixExpression((org.eclipse.jdt.core.dom.PostfixExpression) jdtNode);
    case ASTNode.PREFIX_EXPRESSION:
        return new PrefixExpression((org.eclipse.jdt.core.dom.PrefixExpression) jdtNode);
    case ASTNode.PRIMITIVE_TYPE:
        return new PrimitiveType((org.eclipse.jdt.core.dom.PrimitiveType) jdtNode);
    case ASTNode.QUALIFIED_NAME:
        return new QualifiedName((org.eclipse.jdt.core.dom.QualifiedName) jdtNode);
    case ASTNode.QUALIFIED_TYPE:
        return new QualifiedType((org.eclipse.jdt.core.dom.QualifiedType) jdtNode);
    case ASTNode.RETURN_STATEMENT:
        return new ReturnStatement((org.eclipse.jdt.core.dom.ReturnStatement) jdtNode);
    case ASTNode.SIMPLE_NAME:
        return new SimpleName((org.eclipse.jdt.core.dom.SimpleName) jdtNode);
    case ASTNode.SIMPLE_TYPE:
        return new SimpleType((org.eclipse.jdt.core.dom.SimpleType) jdtNode);
    case ASTNode.SINGLE_MEMBER_ANNOTATION:
        return SingleMemberAnnotation.convert((org.eclipse.jdt.core.dom.SingleMemberAnnotation) jdtNode);
    case ASTNode.SINGLE_VARIABLE_DECLARATION:
        return new SingleVariableDeclaration((org.eclipse.jdt.core.dom.SingleVariableDeclaration) jdtNode);
    case ASTNode.STRING_LITERAL:
        return new StringLiteral((org.eclipse.jdt.core.dom.StringLiteral) jdtNode);
    case ASTNode.SUPER_CONSTRUCTOR_INVOCATION:
        return new SuperConstructorInvocation((org.eclipse.jdt.core.dom.SuperConstructorInvocation) jdtNode);
    case ASTNode.SUPER_FIELD_ACCESS:
        return new SuperFieldAccess((org.eclipse.jdt.core.dom.SuperFieldAccess) jdtNode);
    case ASTNode.SUPER_METHOD_INVOCATION:
        return new SuperMethodInvocation((org.eclipse.jdt.core.dom.SuperMethodInvocation) jdtNode);
    case ASTNode.SUPER_METHOD_REFERENCE:
        return new SuperMethodReference((org.eclipse.jdt.core.dom.SuperMethodReference) jdtNode);
    case ASTNode.SWITCH_CASE:
        return new SwitchCase((org.eclipse.jdt.core.dom.SwitchCase) jdtNode);
    case ASTNode.SWITCH_STATEMENT:
        return new SwitchStatement((org.eclipse.jdt.core.dom.SwitchStatement) jdtNode);
    case ASTNode.SYNCHRONIZED_STATEMENT:
        return new SynchronizedStatement((org.eclipse.jdt.core.dom.SynchronizedStatement) jdtNode);
    case ASTNode.TAG_ELEMENT:
        return new TagElement((org.eclipse.jdt.core.dom.TagElement) jdtNode);
    case ASTNode.TEXT_ELEMENT:
        return new TextElement((org.eclipse.jdt.core.dom.TextElement) jdtNode);
    case ASTNode.THIS_EXPRESSION:
        return new ThisExpression((org.eclipse.jdt.core.dom.ThisExpression) jdtNode);
    case ASTNode.THROW_STATEMENT:
        return new ThrowStatement((org.eclipse.jdt.core.dom.ThrowStatement) jdtNode);
    case ASTNode.TRY_STATEMENT:
        return new TryStatement((org.eclipse.jdt.core.dom.TryStatement) jdtNode);
    case ASTNode.TYPE_DECLARATION:
        return new TypeDeclaration((org.eclipse.jdt.core.dom.TypeDeclaration) jdtNode);
    case ASTNode.TYPE_DECLARATION_STATEMENT:
        return new TypeDeclarationStatement((org.eclipse.jdt.core.dom.TypeDeclarationStatement) jdtNode);
    case ASTNode.TYPE_LITERAL:
        return new TypeLiteral((org.eclipse.jdt.core.dom.TypeLiteral) jdtNode);
    case ASTNode.TYPE_METHOD_REFERENCE:
        return new TypeMethodReference((org.eclipse.jdt.core.dom.TypeMethodReference) jdtNode);
    case ASTNode.UNION_TYPE:
        return new UnionType((org.eclipse.jdt.core.dom.UnionType) jdtNode);
    case ASTNode.VARIABLE_DECLARATION_EXPRESSION:
        return new VariableDeclarationExpression(
                (org.eclipse.jdt.core.dom.VariableDeclarationExpression) jdtNode);
    case ASTNode.VARIABLE_DECLARATION_FRAGMENT:
        return new VariableDeclarationFragment((org.eclipse.jdt.core.dom.VariableDeclarationFragment) jdtNode);
    case ASTNode.VARIABLE_DECLARATION_STATEMENT:
        return new VariableDeclarationStatement(
                (org.eclipse.jdt.core.dom.VariableDeclarationStatement) jdtNode);
    case ASTNode.WHILE_STATEMENT:
        return new WhileStatement((org.eclipse.jdt.core.dom.WhileStatement) jdtNode);
    // These nodes only appear in comments and J2ObjC doens't need any
    // information from their subtree so we just convert them to TextElement.
    case ASTNode.MEMBER_REF:
    case ASTNode.METHOD_REF:
    case ASTNode.METHOD_REF_PARAMETER:
        return new TextElement(jdtNode);
    case ASTNode.COMPILATION_UNIT:
        throw new AssertionError("CompilationUnit must be converted using convertCompilationUnit()");
    default://  w  w  w . ja v a  2s.c  om
        throw new AssertionError("Unknown node type: " + jdtNode.getClass().getName());
    }
}

From source file:org.autorefactor.refactoring.ASTHelper.java

License:Open Source License

/**
 * Returns whether the two provided nodes structurally match.
 *
 * @param matcher the AST matcher/*from   w  w w. j  av a  2 s .c om*/
 * @param node1 the first node to compare
 * @param node2 the second node to compare
 * @return true if the two provided nodes structurally match, false otherwise
 */
public static boolean match(ASTMatcher matcher, ASTNode node1, ASTNode node2) {
    if (sameClass(node1, node2)) {
        // FIXME JNR implement all expressions
        // TODO JNR
        // can we match "this.ast" and the unqualified "ast" for example?
        // can we match "MyClass.CONSTANT" and the unqualified "CONSTANT" for example?
        // can we use IVariableBindings to compare them?
        switch (node1.getNodeType()) {
        case ASTNode.ANNOTATION_TYPE_DECLARATION:
            return matcher.match((AnnotationTypeDeclaration) node1, node2);
        case ASTNode.ANNOTATION_TYPE_MEMBER_DECLARATION:
            return matcher.match((AnnotationTypeMemberDeclaration) node1, node2);
        case ASTNode.ANONYMOUS_CLASS_DECLARATION:
            return matcher.match((AnonymousClassDeclaration) node1, node2);
        case ASTNode.ARRAY_ACCESS:
            return matcher.match((ArrayAccess) node1, node2);
        case ASTNode.ARRAY_CREATION:
            return matcher.match((ArrayCreation) node1, node2);
        case ASTNode.ARRAY_INITIALIZER:
            return matcher.match((ArrayInitializer) node1, node2);
        case ASTNode.ARRAY_TYPE:
            return matcher.match((ArrayType) node1, node2);
        case ASTNode.ASSERT_STATEMENT:
            return matcher.match((AssertStatement) node1, node2);
        case ASTNode.ASSIGNMENT:
            return matcher.match((Assignment) node1, node2);
        case ASTNode.BLOCK:
            return matcher.match((Block) node1, node2);
        case ASTNode.BLOCK_COMMENT:
            return matcher.match((BlockComment) node1, node2);
        case ASTNode.BOOLEAN_LITERAL:
            return matcher.match((BooleanLiteral) node1, node2);
        case ASTNode.BREAK_STATEMENT:
            return matcher.match((BreakStatement) node1, node2);
        case ASTNode.CAST_EXPRESSION:
            return matcher.match((CastExpression) node1, node2);
        case ASTNode.CATCH_CLAUSE:
            return matcher.match((CatchClause) node1, node2);
        case ASTNode.CHARACTER_LITERAL:
            return matcher.match((CharacterLiteral) node1, node2);
        case ASTNode.CLASS_INSTANCE_CREATION:
            return matcher.match((ClassInstanceCreation) node1, node2);
        case ASTNode.COMPILATION_UNIT:
            return matcher.match((CompilationUnit) node1, node2);
        case ASTNode.CONDITIONAL_EXPRESSION:
            return matcher.match((ConditionalExpression) node1, node2);
        case ASTNode.CONSTRUCTOR_INVOCATION:
            return matcher.match((ConstructorInvocation) node1, node2);
        case ASTNode.CONTINUE_STATEMENT:
            return matcher.match((ContinueStatement) node1, node2);
        case ASTNode.DO_STATEMENT:
            return matcher.match((DoStatement) node1, node2);
        case ASTNode.EMPTY_STATEMENT:
            return matcher.match((EmptyStatement) node1, node2);
        case ASTNode.ENHANCED_FOR_STATEMENT:
            return matcher.match((EnhancedForStatement) node1, node2);
        case ASTNode.ENUM_DECLARATION:
            return matcher.match((EnumDeclaration) node1, node2);
        case ASTNode.ENUM_CONSTANT_DECLARATION:
            return matcher.match((EnumConstantDeclaration) node1, node2);
        case ASTNode.EXPRESSION_STATEMENT:
            return matcher.match((ExpressionStatement) node1, node2);
        case ASTNode.FIELD_ACCESS:
            return matcher.match((FieldAccess) node1, node2);
        case ASTNode.FIELD_DECLARATION:
            return matcher.match((FieldDeclaration) node1, node2);
        case ASTNode.FOR_STATEMENT:
            return matcher.match((ForStatement) node1, node2);
        case ASTNode.IF_STATEMENT:
            return matcher.match((IfStatement) node1, node2);
        case ASTNode.IMPORT_DECLARATION:
            return matcher.match((ImportDeclaration) node1, node2);
        case ASTNode.INFIX_EXPRESSION:
            return matcher.match((InfixExpression) node1, node2);
        case ASTNode.INITIALIZER:
            return matcher.match((Initializer) node1, node2);
        case ASTNode.INSTANCEOF_EXPRESSION:
            return matcher.match((InstanceofExpression) node1, node2);
        case ASTNode.JAVADOC:
            return matcher.match((Javadoc) node1, node2);
        case ASTNode.LABELED_STATEMENT:
            return matcher.match((LabeledStatement) node1, node2);
        case ASTNode.LINE_COMMENT:
            return matcher.match((LineComment) node1, node2);
        case ASTNode.MARKER_ANNOTATION:
            return matcher.match((MarkerAnnotation) node1, node2);
        case ASTNode.MEMBER_REF:
            return matcher.match((MemberRef) node1, node2);
        case ASTNode.MEMBER_VALUE_PAIR:
            return matcher.match((MemberValuePair) node1, node2);
        case ASTNode.METHOD_DECLARATION:
            return matcher.match((MethodDeclaration) node1, node2);
        case ASTNode.METHOD_INVOCATION:
            return matcher.match((MethodInvocation) node1, node2);
        case ASTNode.METHOD_REF:
            return matcher.match((MethodRef) node1, node2);
        case ASTNode.METHOD_REF_PARAMETER:
            return matcher.match((MethodRefParameter) node1, node2);
        case ASTNode.MODIFIER:
            return matcher.match((Modifier) node1, node2);
        case ASTNode.NORMAL_ANNOTATION:
            return matcher.match((NormalAnnotation) node1, node2);
        case ASTNode.NULL_LITERAL:
            return matcher.match((NullLiteral) node1, node2);
        case ASTNode.NUMBER_LITERAL:
            return matcher.match((NumberLiteral) node1, node2);
        case ASTNode.PACKAGE_DECLARATION:
            return matcher.match((PackageDeclaration) node1, node2);
        case ASTNode.PARAMETERIZED_TYPE:
            return matcher.match((ParameterizedType) node1, node2);
        case ASTNode.PARENTHESIZED_EXPRESSION:
            return matcher.match((ParenthesizedExpression) node1, node2);
        case ASTNode.POSTFIX_EXPRESSION:
            return matcher.match((PostfixExpression) node1, node2);
        case ASTNode.PREFIX_EXPRESSION:
            return matcher.match((PrefixExpression) node1, node2);
        case ASTNode.PRIMITIVE_TYPE:
            return matcher.match((PrimitiveType) node1, node2);
        case ASTNode.QUALIFIED_NAME:
            return matcher.match((QualifiedName) node1, node2);
        case ASTNode.QUALIFIED_TYPE:
            return matcher.match((QualifiedType) node1, node2);
        case ASTNode.RETURN_STATEMENT:
            return matcher.match((ReturnStatement) node1, node2);
        case ASTNode.SIMPLE_NAME:
            return matcher.match((SimpleName) node1, node2);
        case ASTNode.SIMPLE_TYPE:
            return matcher.match((SimpleType) node1, node2);
        case ASTNode.SINGLE_MEMBER_ANNOTATION:
            return matcher.match((SingleMemberAnnotation) node1, node2);
        case ASTNode.SINGLE_VARIABLE_DECLARATION:
            return matcher.match((SingleVariableDeclaration) node1, node2);
        case ASTNode.STRING_LITERAL:
            return matcher.match((StringLiteral) node1, node2);
        case ASTNode.SUPER_CONSTRUCTOR_INVOCATION:
            return matcher.match((SuperConstructorInvocation) node1, node2);
        case ASTNode.SUPER_FIELD_ACCESS:
            return matcher.match((SuperFieldAccess) node1, node2);
        case ASTNode.SUPER_METHOD_INVOCATION:
            return matcher.match((SuperMethodInvocation) node1, node2);
        case ASTNode.SWITCH_CASE:
            return matcher.match((SwitchCase) node1, node2);
        case ASTNode.SWITCH_STATEMENT:
            return matcher.match((SwitchStatement) node1, node2);
        case ASTNode.SYNCHRONIZED_STATEMENT:
            return matcher.match((SynchronizedStatement) node1, node2);
        case ASTNode.TAG_ELEMENT:
            return matcher.match((TagElement) node1, node2);
        case ASTNode.TEXT_ELEMENT:
            return matcher.match((TextElement) node1, node2);
        case ASTNode.THIS_EXPRESSION:
            return matcher.match((ThisExpression) node1, node2);
        case ASTNode.THROW_STATEMENT:
            return matcher.match((ThrowStatement) node1, node2);
        case ASTNode.TRY_STATEMENT:
            return matcher.match((TryStatement) node1, node2);
        case ASTNode.TYPE_DECLARATION:
            return matcher.match((TypeDeclaration) node1, node2);
        case ASTNode.TYPE_DECLARATION_STATEMENT:
            return matcher.match((TypeDeclarationStatement) node1, node2);
        case ASTNode.TYPE_LITERAL:
            return matcher.match((TypeLiteral) node1, node2);
        case ASTNode.TYPE_PARAMETER:
            return matcher.match((TypeParameter) node1, node2);
        case ASTNode.UNION_TYPE:
            return matcher.match((UnionType) node1, node2);
        case ASTNode.VARIABLE_DECLARATION_EXPRESSION:
            return matcher.match((VariableDeclarationExpression) node1, node2);
        case ASTNode.VARIABLE_DECLARATION_FRAGMENT:
            return matcher.match((VariableDeclarationFragment) node1, node2);
        case ASTNode.VARIABLE_DECLARATION_STATEMENT:
            return matcher.match((VariableDeclarationStatement) node1, node2);
        case ASTNode.WHILE_STATEMENT:
            return matcher.match((WhileStatement) node1, node2);
        case ASTNode.WILDCARD_TYPE:
            return matcher.match((WildcardType) node1, node2);
        default:
            throw new NotImplementedException(node1);
        }
    }
    return false;
}

From source file:org.eclipse.scout.sdk.saml.importer.internal.jdt.imports.OrganizeImportsHelper.java

License:Open Source License

private static int internalGetPossibleTypeKinds(ASTNode node) {
    int kind = ALL_TYPES;

    int mask = ALL_TYPES | VOIDTYPE;

    ASTNode parent = node.getParent();//from w w  w .  ja v  a 2  s  .  co m
    while (parent instanceof QualifiedName) {
        if (node.getLocationInParent() == QualifiedName.QUALIFIER_PROPERTY) {
            return REF_TYPES;
        }
        node = parent;
        parent = parent.getParent();
        mask = REF_TYPES;
    }
    while (parent instanceof Type) {
        if (parent instanceof QualifiedType) {
            if (node.getLocationInParent() == QualifiedType.QUALIFIER_PROPERTY) {
                return mask & (REF_TYPES);
            }
            mask &= REF_TYPES;
        } else if (parent instanceof ParameterizedType) {
            if (node.getLocationInParent() == ParameterizedType.TYPE_ARGUMENTS_PROPERTY) {
                return mask & REF_TYPES_AND_VAR;
            }
            mask &= CLASSES | INTERFACES;
        } else if (parent instanceof WildcardType) {
            if (node.getLocationInParent() == WildcardType.BOUND_PROPERTY) {
                return mask & REF_TYPES_AND_VAR;
            }
        }
        node = parent;
        parent = parent.getParent();
    }

    switch (parent.getNodeType()) {
    case ASTNode.TYPE_DECLARATION:
        if (node.getLocationInParent() == TypeDeclaration.SUPER_INTERFACE_TYPES_PROPERTY) {
            kind = INTERFACES;
        } else if (node.getLocationInParent() == TypeDeclaration.SUPERCLASS_TYPE_PROPERTY) {
            kind = CLASSES;
        }
        break;
    case ASTNode.ENUM_DECLARATION:
        kind = INTERFACES;
        break;
    case ASTNode.METHOD_DECLARATION:
        if (node.getLocationInParent() == MethodDeclaration.THROWN_EXCEPTIONS_PROPERTY) {
            kind = CLASSES;
        } else if (node.getLocationInParent() == MethodDeclaration.RETURN_TYPE2_PROPERTY) {
            kind = ALL_TYPES | VOIDTYPE;
        }
        break;
    case ASTNode.ANNOTATION_TYPE_MEMBER_DECLARATION:
        kind = PRIMITIVETYPES | ANNOTATIONS | ENUMS;
        break;
    case ASTNode.INSTANCEOF_EXPRESSION:
        kind = REF_TYPES;
        break;
    case ASTNode.THROW_STATEMENT:
        kind = CLASSES;
        break;
    case ASTNode.CLASS_INSTANCE_CREATION:
        if (((ClassInstanceCreation) parent).getAnonymousClassDeclaration() == null) {
            kind = CLASSES;
        } else {
            kind = CLASSES | INTERFACES;
        }
        break;
    case ASTNode.SINGLE_VARIABLE_DECLARATION:
        int superParent = parent.getParent().getNodeType();
        if (superParent == ASTNode.CATCH_CLAUSE) {
            kind = CLASSES;
        }
        break;
    case ASTNode.TAG_ELEMENT:
        kind = REF_TYPES;
        break;
    case ASTNode.MARKER_ANNOTATION:
    case ASTNode.SINGLE_MEMBER_ANNOTATION:
    case ASTNode.NORMAL_ANNOTATION:
        kind = ANNOTATIONS;
        break;
    case ASTNode.TYPE_PARAMETER:
        if (((TypeParameter) parent).typeBounds().indexOf(node) > 0) {
            kind = INTERFACES;
        } else {
            kind = REF_TYPES_AND_VAR;
        }
        break;
    case ASTNode.TYPE_LITERAL:
        kind = REF_TYPES;
        break;
    default:
    }
    return kind & mask;
}

From source file:refactorer.Refactorer.java

License:Apache License

@SuppressWarnings("unchecked")
protected void processStatement(Statement statement) {
    if (statement == null)
        return;/*from  w  ww .jav a 2 s  . c  om*/

    switch (statement.getNodeType()) {
    case ASTNode.ASSERT_STATEMENT:
    case ASTNode.BREAK_STATEMENT:
    case ASTNode.CONTINUE_STATEMENT:
    case ASTNode.EMPTY_STATEMENT:
    case ASTNode.LABELED_STATEMENT:
        //ignore
        break;
    case ASTNode.BLOCK:
        variables.push();
        Block block = (Block) statement;
        for (Statement s : (List<Statement>) block.statements()) {
            processStatement(s);
        }
        variables.pop();
        break;
    case ASTNode.CONSTRUCTOR_INVOCATION:
        ConstructorInvocation constructorInvocation = (ConstructorInvocation) statement;
        for (Expression e : (List<Expression>) constructorInvocation.arguments()) {
            processExpression(e);
        }
        break;
    case ASTNode.DO_STATEMENT:
        DoStatement doStatement = (DoStatement) statement;
        processExpression(doStatement.getExpression());
        processStatement(doStatement.getBody());
        break;
    case ASTNode.ENHANCED_FOR_STATEMENT:
        EnhancedForStatement enhancedForStatement = (EnhancedForStatement) statement;
        processSingleVariableDeclaration(enhancedForStatement.getParameter());
        processExpression(enhancedForStatement.getExpression());
        processStatement(enhancedForStatement.getBody());
        break;
    case ASTNode.EXPRESSION_STATEMENT:
        ExpressionStatement expressionStatement = (ExpressionStatement) statement;
        processExpression(expressionStatement.getExpression());
        break;
    case ASTNode.FOR_STATEMENT:
        ForStatement forStatement = (ForStatement) statement;
        for (Expression e : (List<Expression>) forStatement.initializers()) {
            processExpression(e);
        }
        processExpression(forStatement.getExpression());
        for (Expression e : (List<Expression>) forStatement.updaters()) {
            processExpression(e);
        }
        processStatement(forStatement.getBody());
        break;
    case ASTNode.IF_STATEMENT:
        IfStatement ifStatement = (IfStatement) statement;
        processExpression(ifStatement.getExpression());
        processStatement(ifStatement.getThenStatement());
        processStatement(ifStatement.getElseStatement());
        break;
    case ASTNode.RETURN_STATEMENT:
        ReturnStatement returnStatement = (ReturnStatement) statement;
        processExpression(returnStatement.getExpression());
        break;
    case ASTNode.SUPER_CONSTRUCTOR_INVOCATION:
        SuperConstructorInvocation superConstructorInvocation = (SuperConstructorInvocation) statement;
        processExpression(superConstructorInvocation.getExpression());
        for (Expression e : (List<Expression>) superConstructorInvocation.arguments()) {
            processExpression(e);
        }
        break;
    case ASTNode.SWITCH_CASE:
        SwitchCase switchCase = (SwitchCase) statement;
        processExpression(switchCase.getExpression());
        break;
    case ASTNode.SWITCH_STATEMENT:
        SwitchStatement switchStatement = (SwitchStatement) statement;
        processExpression(switchStatement.getExpression());
        for (Statement s : (List<Statement>) switchStatement.statements()) {
            processStatement(s);
        }
        break;
    case ASTNode.SYNCHRONIZED_STATEMENT:
        SynchronizedStatement synchronizedStatement = (SynchronizedStatement) statement;
        processExpression(synchronizedStatement.getExpression());
        processStatement(synchronizedStatement.getBody());
        break;
    case ASTNode.THROW_STATEMENT:
        ThrowStatement throwStatement = (ThrowStatement) statement;
        processExpression(throwStatement.getExpression());
        break;
    case ASTNode.TRY_STATEMENT:
        TryStatement tryStatement = (TryStatement) statement;
        processStatement(tryStatement.getBody());
        for (CatchClause cc : (List<CatchClause>) tryStatement.catchClauses()) {
            processStatement(cc.getBody());
        }
        processStatement(tryStatement.getFinally());
        break;
    case ASTNode.TYPE_DECLARATION_STATEMENT:
        TypeDeclarationStatement typeDeclarationStatement = (TypeDeclarationStatement) statement;
        processTypeDeclaration(typeDeclarationStatement.getDeclaration());
        break;
    case ASTNode.VARIABLE_DECLARATION_STATEMENT:
        VariableDeclarationStatement variableDeclarationStatement = (VariableDeclarationStatement) statement;
        processVariableDeclarationStatement(variableDeclarationStatement);
        break;
    case ASTNode.WHILE_STATEMENT:
        WhileStatement whileStatement = (WhileStatement) statement;
        processExpression(whileStatement.getExpression());
        processStatement(whileStatement.getBody());
        break;
    }
}