List of usage examples for org.eclipse.jdt.core.dom ASTNode SUPER_FIELD_ACCESS
int SUPER_FIELD_ACCESS
To view the source code for org.eclipse.jdt.core.dom ASTNode SUPER_FIELD_ACCESS.
Click Source Link
SuperFieldAccess. 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:/*from w ww . j av a 2 s. 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:/*from www . ja va 2s. c o m*/ throw new AssertionError("Unknown node type: " + jdtNode.getClass().getName()); } }
From source file:com.intel.ide.eclipse.mpt.ast.UnresolvedElementsSubProcessor.java
License:Open Source License
public static void getVariableProposals(IInvocationContext context, IProblemLocation problem, IVariableBinding resolvedField, Map<String, Map> proposals) throws CoreException { ICompilationUnit cu = context.getCompilationUnit(); CompilationUnit astRoot = context.getASTRoot(); ASTNode selectedNode = problem.getCoveredNode(astRoot); if (selectedNode == null) { return;// w w w . j ava2 s . com } // type that defines the variable ITypeBinding binding = null; ITypeBinding declaringTypeBinding = Bindings.getBindingOfParentTypeContext(selectedNode); if (declaringTypeBinding == null) { return; } // possible type kind of the node boolean suggestVariableProposals = true; while (selectedNode instanceof ParenthesizedExpression) { selectedNode = ((ParenthesizedExpression) selectedNode).getExpression(); } Name node = null; switch (selectedNode.getNodeType()) { case ASTNode.SIMPLE_NAME: node = (SimpleName) selectedNode; if (!isVariableProposalSafe(node)) return; ASTNode parent = node.getParent(); StructuralPropertyDescriptor locationInParent = node.getLocationInParent(); if (locationInParent == MethodInvocation.EXPRESSION_PROPERTY) { } else if (locationInParent == FieldAccess.NAME_PROPERTY) { Expression expression = ((FieldAccess) parent).getExpression(); if (expression != null) { binding = expression.resolveTypeBinding(); if (binding == null) { node = null; } } } else if (parent instanceof SimpleType) { suggestVariableProposals = false; } else if (parent instanceof QualifiedName) { Name qualifier = ((QualifiedName) parent).getQualifier(); if (qualifier != node) { binding = qualifier.resolveTypeBinding(); } else { } ASTNode outerParent = parent.getParent(); while (outerParent instanceof QualifiedName) { outerParent = outerParent.getParent(); } if (outerParent instanceof SimpleType) { suggestVariableProposals = false; } } else if (locationInParent == SwitchCase.EXPRESSION_PROPERTY) { ITypeBinding switchExp = ((SwitchStatement) node.getParent().getParent()).getExpression() .resolveTypeBinding(); if (switchExp != null && switchExp.isEnum()) { binding = switchExp; } } else if (locationInParent == SuperFieldAccess.NAME_PROPERTY) { binding = declaringTypeBinding.getSuperclass(); } break; case ASTNode.QUALIFIED_NAME: QualifiedName qualifierName = (QualifiedName) selectedNode; ITypeBinding qualifierBinding = qualifierName.getQualifier().resolveTypeBinding(); if (qualifierBinding != null) { node = qualifierName.getName(); binding = qualifierBinding; } else { node = qualifierName.getQualifier(); suggestVariableProposals = node.isSimpleName(); } if (selectedNode.getParent() instanceof SimpleType) { suggestVariableProposals = false; } break; case ASTNode.FIELD_ACCESS: FieldAccess access = (FieldAccess) selectedNode; Expression expression = access.getExpression(); if (expression != null) { binding = expression.resolveTypeBinding(); if (binding != null) { node = access.getName(); } } break; case ASTNode.SUPER_FIELD_ACCESS: binding = declaringTypeBinding.getSuperclass(); node = ((SuperFieldAccess) selectedNode).getName(); break; default: } if (node == null) { return; } if (!suggestVariableProposals) { return; } SimpleName simpleName = node.isSimpleName() ? (SimpleName) node : ((QualifiedName) node).getName(); boolean isWriteAccess = ASTResolving.isWriteAccess(node); if (resolvedField == null || binding == null || resolvedField.getDeclaringClass() != binding.getTypeDeclaration() && Modifier.isPrivate(resolvedField.getModifiers())) { // new fields addNewFieldProposals(cu, astRoot, binding, declaringTypeBinding, simpleName, isWriteAccess, proposals); } }
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://from w ww. j a v a 2 s . c om throw new AssertionError("Unknown node type: " + jdtNode.getClass().getName()); } }
From source file:edu.illinois.jflow.core.transformations.code.SnippetFinder.java
License:Open Source License
private static boolean isLeftHandSideOfAssignment(ASTNode node) { Assignment assignment = (Assignment) ASTNodes.getParent(node, ASTNode.ASSIGNMENT); if (assignment != null) { Expression leftHandSide = assignment.getLeftHandSide(); if (leftHandSide == node) { return true; }/*from ww w .j av a2s .c om*/ if (ASTNodes.isParent(node, leftHandSide)) { switch (leftHandSide.getNodeType()) { case ASTNode.SIMPLE_NAME: return true; case ASTNode.FIELD_ACCESS: return node == ((FieldAccess) leftHandSide).getName(); case ASTNode.QUALIFIED_NAME: return node == ((QualifiedName) leftHandSide).getName(); case ASTNode.SUPER_FIELD_ACCESS: return node == ((SuperFieldAccess) leftHandSide).getName(); default: return false; } } } return false; }
From source file:egovframework.mgt.fit.library.parser.visitor.MethodParsingVisitor.java
License:Apache License
/** * ? ? ? .//from w ww .j a v a2s .c o m * @return */ private MethodInvoke processInvocation(MethodInvocation node) { method.addParsedInvocation(node.getStartPosition()); MethodInvoke mi = new MethodInvoke(); UnitList<Variable> args = new UnitList<Variable>(); Project p = method.getProject(); for (Object o : node.arguments()) { if (o instanceof SimpleName) { Variable targetField; String argName = ((SimpleName) o).getFullyQualifiedName(); JavaClass checkType = method.getType(); targetField = method.getLocalVariable(argName); while (true) { if (targetField == null) { targetField = checkType.getField(argName); } if (targetField != null) { args.addUnit(targetField); break; } checkType = checkType.getSuperClass(); if (!checkType.isProjectClass()) { DebugLog.log("Failed!!!!"); break; } } } else if (o instanceof Expression) { Expression e = (Expression) o; switch (e.getNodeType()) { case ASTNode.BOOLEAN_LITERAL: args.addUnit(new Variable(p.BOOLEAN_CLASS, ObjectHelper.getUniqueKey("Literal"), String.valueOf(((BooleanLiteral) e).booleanValue()))); break; case ASTNode.CHARACTER_LITERAL: args.addUnit(new Variable(p.CHAR_CLASS, ObjectHelper.getUniqueKey("Literal"), String.valueOf(((CharacterLiteral) e).charValue()))); break; case ASTNode.FIELD_ACCESS: FieldAccess fa = (FieldAccess) e; break; case ASTNode.NULL_LITERAL: args.addUnit(Variable.getNullVariable(p.OBJECT_CLASS, ObjectHelper.getUniqueKey("Literal"))); break; case ASTNode.NUMBER_LITERAL: args.addUnit(parseNumberLiteral(((NumberLiteral) e).getToken(), p)); break; case ASTNode.STRING_LITERAL: args.addUnit(new Variable(p.STRING_CLASS, ObjectHelper.getUniqueKey("Literal"), String.valueOf(((StringLiteral) e).getLiteralValue()))); break; case ASTNode.SUPER_FIELD_ACCESS: break; case ASTNode.THIS_EXPRESSION: break; case ASTNode.MEMBER_REF: break; case ASTNode.METHOD_REF: break; case ASTNode.TYPE_LITERAL: args.addUnit(new Variable(p.TYPE_CLASS, ObjectHelper.getUniqueKey("Literal"), String.valueOf(((TypeLiteral) e)))); break; case ASTNode.PREFIX_EXPRESSION: PrefixExpression pe = (PrefixExpression) e; if (pe.getOperator().equals(PrefixExpression.Operator.PLUS)) { args.addUnit(parseNumberLiteral(pe.getOperand().toString(), p)); } else if (pe.getOperator().equals(PrefixExpression.Operator.MINUS)) { args.addUnit(parseNumberLiteral("-", pe.getOperand().toString(), p)); } default: break; } } } mi.setFromMethod(method); mi.setArguments(args.clone()); String methodKey = StringHelper.getMethodKeyString(node.getName().getFullyQualifiedName(), args); Expression e = node.getExpression(); if (e == null) { // ?? method super ?? method ? // (? Super Method Invocation? // visit) JavaClass checkType = method.getType(); if (node.toString().equals("getCategory(vo,searchVO)")) { System.out.println("!"); } while (true) { if (checkType.isProjectClass()) { for (Method m : checkType.getMethods()) { if (StringHelper.getMethodKeyString(m).equals(methodKey)) { mi.setToMethod(m); break; } } } else { Method toM = new Method(p); toM.setType(checkType); toM.setName(node.getName().getFullyQualifiedName()); toM.setReturnType(p.UNKNOWN_CLASS); for (Variable v : args) { Variable tempParam = new Variable(); tempParam.setName(v.getName()); tempParam.setType(v.getType()); toM.addParameter(tempParam); } mi.setToMethod(toM); break; } if (mi.getToMethod() != null) { break; } checkType = checkType.getSuperClass(); } } else { // ?? switch (e.getNodeType()) { case ASTNode.SIMPLE_NAME: Variable targetField; String argName = ((SimpleName) e).getFullyQualifiedName(); JavaClass checkType = method.getType(); targetField = method.getLocalVariable(argName); JavaClass callType = null; while (true) { if (targetField == null) { targetField = checkType.getField(argName); } if (targetField != null) { callType = targetField.getType(); break; } checkType = checkType.getSuperClass(); if (!checkType.isProjectClass()) { if ((callType = p.resolveClass(ParsingHelper.getFullNameWithSimpleName(argName, checkType.getPackage(), checkType.getImports()))) != null) { break; } break; } } if (callType != null) { if (callType.isProjectClass()) { for (Method m : callType.getMethods()) { if (StringHelper.getMethodKeyString(m).equals(methodKey)) { mi.setToMethod(m); break; } } } else { Method toM = new Method(p); toM.setType(callType); toM.setName(node.getName().getFullyQualifiedName()); toM.setReturnType(p.UNKNOWN_CLASS); for (Variable v : args) { Variable tempParam = new Variable(); tempParam.setName(v.getName()); tempParam.setType(v.getType()); toM.addParameter(tempParam); } mi.setToMethod(toM); } } break; case ASTNode.METHOD_INVOCATION: MethodInvoke mik = processInvocation((MethodInvocation) e); if (mik.getToMethod() == null) { break; } JavaClass jc = mik.getToMethod().getReturnType(); if (jc == null || jc == p.UNKNOWN_CLASS) { break; } for (Method m : jc.getMethods()) { if (StringHelper.getMethodKeyString(m).equals(methodKey)) { mi.setToMethod(m); break; } } break; case ASTNode.STRING_LITERAL: Method toM = new Method(p); toM.setType(p.STRING_CLASS); toM.setName(node.getName().getFullyQualifiedName()); toM.setReturnType(p.UNKNOWN_CLASS); for (Variable v : args) { Variable tempParam = new Variable(); tempParam.setName(v.getName()); tempParam.setType(v.getType()); toM.addParameter(tempParam); } mi.setToMethod(toM); break; case ASTNode.SUPER_METHOD_INVOCATION: toM = new Method(p); toM.setType(method.getType().getSuperClass()); toM.setName(node.getName().getFullyQualifiedName()); toM.setReturnType(p.UNKNOWN_CLASS); for (Variable v : args) { Variable tempParam = new Variable(); tempParam.setName(v.getName()); tempParam.setType(v.getType()); toM.addParameter(tempParam); } mi.setToMethod(toM); break; case ASTNode.PARENTHESIZED_EXPRESSION: break; case ASTNode.ARRAY_ACCESS: break; case ASTNode.FIELD_ACCESS: break; case ASTNode.THIS_EXPRESSION: break; case ASTNode.QUALIFIED_NAME: break; case ASTNode.CLASS_INSTANCE_CREATION: ClassInstanceCreation cic = (ClassInstanceCreation) e; JavaClass createdType = p.resolveClass(ParsingHelper.getFullNameWithSimpleName( cic.getType().toString(), method.getType().getPackage(), method.getType().getImports())); for (Method m : createdType.getMethods()) { if (StringHelper.getMethodKeyString(m).equals(methodKey)) { mi.setToMethod(m); break; } } break; default: } // System.out.println("--->"+node.getExpression().toString()); } if (mi.getFromMethod() != null && mi.getToMethod() != null) { p.addInvocation(mi); } else { //System.out.println("Fail....TT"); } return mi; // System.out.println("invoke : " + node.toString()); }
From source file:net.sf.j2s.core.astvisitors.Bindings.java
License:Open Source License
/** * Returns the binding of the variable written in an Assignment. * @param assignment The assignment /* ww w. ja v a 2s .co m*/ * @return The binding or <code>null</code> if no bindings are available. */ public static IVariableBinding getAssignedVariable(Assignment assignment) { Expression leftHand = assignment.getLeftHandSide(); switch (leftHand.getNodeType()) { case ASTNode.SIMPLE_NAME: return (IVariableBinding) ((SimpleName) leftHand).resolveBinding(); case ASTNode.QUALIFIED_NAME: return (IVariableBinding) ((QualifiedName) leftHand).getName().resolveBinding(); case ASTNode.FIELD_ACCESS: return ((FieldAccess) leftHand).resolveFieldBinding(); case ASTNode.SUPER_FIELD_ACCESS: return ((SuperFieldAccess) leftHand).resolveFieldBinding(); default: return null; } }
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 www . j ava 2 s.c o m * @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.autorefactor.refactoring.rules.OperatorEnum.java
License:Open Source License
/** * Returns the equivalent {@link OperatorEnum} for the operator used inside * the supplied node. Although this method accepts an {@link ASTNode}, the * provided node must be an expression.//from w w w. j a v a 2s .c om * * @param expr * the expression node * @return the equivalent {@link OperatorEnum} for the operator used inside * the supplied node, null if the supplied node is not an expression * or if it does not use an operator */ public static OperatorEnum getOperator(ASTNode expr) { if (expr == null) { return null; } switch (expr.getNodeType()) { case ASTNode.PREFIX_EXPRESSION: return OPERATORS.get(((PrefixExpression) expr).getOperator()); case ASTNode.POSTFIX_EXPRESSION: return OPERATORS.get(((PostfixExpression) expr).getOperator()); case ASTNode.INFIX_EXPRESSION: return OPERATORS.get(((InfixExpression) expr).getOperator()); case ASTNode.METHOD_INVOCATION: case ASTNode.SUPER_METHOD_INVOCATION: return PARENTHESES; case ASTNode.ASSIGNMENT: return OPERATORS.get(((Assignment) expr).getOperator()); case ASTNode.VARIABLE_DECLARATION_FRAGMENT: return ASSIGN; case ASTNode.FIELD_ACCESS: case ASTNode.SUPER_FIELD_ACCESS: case ASTNode.THIS_EXPRESSION: return DOT; case ASTNode.INSTANCEOF_EXPRESSION: return INSTANCEOF; case ASTNode.CAST_EXPRESSION: return CAST; case ASTNode.CLASS_INSTANCE_CREATION: case ASTNode.ARRAY_CREATION: return NEW; case ASTNode.ARRAY_ACCESS: return ARRAY_ACCESS; case ASTNode.CONDITIONAL_EXPRESSION: return TERNARY; default: return null; } }
From source file:org.eclipse.ajdt.internal.ui.editor.quickfix.UnresolvedElementsSubProcessor.java
License:Open Source License
public static void getVariableProposals(IInvocationContext context, IProblemLocation problem, IVariableBinding resolvedField, Collection proposals) throws CoreException { ICompilationUnit cu = context.getCompilationUnit(); CompilationUnit astRoot = context.getASTRoot(); ASTNode selectedNode = problem.getCoveredNode(astRoot); if (selectedNode == null) { return;//from w w w. j ava2 s. c o m } // type that defines the variable ITypeBinding binding = null; ITypeBinding declaringTypeBinding = Bindings.getBindingOfParentTypeContext(selectedNode); if (declaringTypeBinding == null) { return; } // possible type kind of the node boolean suggestVariableProposals = true; int typeKind = 0; while (selectedNode instanceof ParenthesizedExpression) { selectedNode = ((ParenthesizedExpression) selectedNode).getExpression(); } Name node = null; switch (selectedNode.getNodeType()) { case ASTNode.SIMPLE_NAME: node = (SimpleName) selectedNode; ASTNode parent = node.getParent(); StructuralPropertyDescriptor locationInParent = node.getLocationInParent(); if (locationInParent == MethodInvocation.EXPRESSION_PROPERTY) { typeKind = SimilarElementsRequestor.CLASSES; } else if (locationInParent == FieldAccess.NAME_PROPERTY) { Expression expression = ((FieldAccess) parent).getExpression(); if (expression != null) { binding = expression.resolveTypeBinding(); if (binding == null) { node = null; } } } else if (parent instanceof SimpleType) { suggestVariableProposals = false; typeKind = SimilarElementsRequestor.REF_TYPES; } else if (parent instanceof QualifiedName) { Name qualifier = ((QualifiedName) parent).getQualifier(); if (qualifier != node) { binding = qualifier.resolveTypeBinding(); } else { typeKind = SimilarElementsRequestor.REF_TYPES & ~SimilarElementsRequestor.VARIABLES; } ASTNode outerParent = parent.getParent(); while (outerParent instanceof QualifiedName) { outerParent = outerParent.getParent(); } if (outerParent instanceof SimpleType) { typeKind = SimilarElementsRequestor.REF_TYPES & ~SimilarElementsRequestor.VARIABLES; suggestVariableProposals = false; } } else if (locationInParent == SwitchCase.EXPRESSION_PROPERTY) { ITypeBinding switchExp = ((SwitchStatement) node.getParent().getParent()).getExpression() .resolveTypeBinding(); if (switchExp != null && switchExp.isEnum()) { binding = switchExp; } } else if (locationInParent == SuperFieldAccess.NAME_PROPERTY) { binding = declaringTypeBinding.getSuperclass(); } break; case ASTNode.QUALIFIED_NAME: QualifiedName qualifierName = (QualifiedName) selectedNode; ITypeBinding qualifierBinding = qualifierName.getQualifier().resolveTypeBinding(); if (qualifierBinding != null) { node = qualifierName.getName(); binding = qualifierBinding; } else { node = qualifierName.getQualifier(); typeKind = SimilarElementsRequestor.REF_TYPES & ~SimilarElementsRequestor.VARIABLES; suggestVariableProposals = node.isSimpleName(); } if (selectedNode.getParent() instanceof SimpleType) { typeKind = SimilarElementsRequestor.REF_TYPES & ~SimilarElementsRequestor.VARIABLES; suggestVariableProposals = false; } break; case ASTNode.FIELD_ACCESS: FieldAccess access = (FieldAccess) selectedNode; Expression expression = access.getExpression(); if (expression != null) { binding = expression.resolveTypeBinding(); if (binding != null) { node = access.getName(); } } break; case ASTNode.SUPER_FIELD_ACCESS: binding = declaringTypeBinding.getSuperclass(); node = ((SuperFieldAccess) selectedNode).getName(); break; default: } if (node == null) { return; } // add type proposals if (typeKind != 0) { if (!JavaModelUtil.is50OrHigher(cu.getJavaProject())) { typeKind = typeKind & ~(SimilarElementsRequestor.ANNOTATIONS | SimilarElementsRequestor.ENUMS | SimilarElementsRequestor.VARIABLES); } int relevance = Character.isUpperCase(ASTNodes.getSimpleNameIdentifier(node).charAt(0)) ? 5 : -2; addSimilarTypeProposals(typeKind, cu, node, relevance + 1, proposals); addNewTypeProposals(cu, node, typeKind, relevance, proposals); } if (!suggestVariableProposals) { return; } SimpleName simpleName = node.isSimpleName() ? (SimpleName) node : ((QualifiedName) node).getName(); boolean isWriteAccess = ASTResolving.isWriteAccess(node); // similar variables addSimilarVariableProposals(cu, astRoot, binding, simpleName, isWriteAccess, proposals); if (resolvedField == null || binding == null || resolvedField.getDeclaringClass() != binding.getTypeDeclaration() && Modifier.isPrivate(resolvedField.getModifiers())) { // new fields addNewFieldProposals(cu, astRoot, binding, declaringTypeBinding, simpleName, isWriteAccess, proposals); // new parameters and local variables if (binding == null) { addNewVariableProposals(cu, node, simpleName, proposals); } } }