List of usage examples for org.eclipse.jdt.core.dom ASTNode RETURN_STATEMENT
int RETURN_STATEMENT
To view the source code for org.eclipse.jdt.core.dom ASTNode RETURN_STATEMENT.
Click Source Link
ReturnStatement. From source file:ca.mcgill.cs.swevo.ppa.PPAIndexer.java
License:Open Source License
private void initStrategies() { strategies.put(FIELD_TYPE, new FieldInferenceStrategy(this, ppaEngine)); strategies.put(ASTNode.ASSIGNMENT, new AssignInferenceStrategy(this, ppaEngine)); strategies.put(ASTNode.QUALIFIED_NAME, new QNameInferenceStrategy(this, ppaEngine)); strategies.put(ASTNode.RETURN_STATEMENT, new ReturnInferenceStrategy(this, ppaEngine)); strategies.put(ASTNode.VARIABLE_DECLARATION_FRAGMENT, new VariableDeclarationInferenceStrategy(this, ppaEngine)); strategies.put(ASTNode.METHOD_INVOCATION, new MethodInferenceStrategy(this, ppaEngine)); strategies.put(ASTNode.SUPER_METHOD_INVOCATION, new MethodInferenceStrategy(this, ppaEngine)); strategies.put(ASTNode.FOR_STATEMENT, new ConditionInferenceStrategy(this, ppaEngine)); strategies.put(ASTNode.WHILE_STATEMENT, new ConditionInferenceStrategy(this, ppaEngine)); strategies.put(ASTNode.DO_STATEMENT, new ConditionInferenceStrategy(this, ppaEngine)); strategies.put(ASTNode.IF_STATEMENT, new ConditionInferenceStrategy(this, ppaEngine)); strategies.put(ASTNode.INFIX_EXPRESSION, new BinaryInferenceStrategy(this, ppaEngine)); strategies.put(ASTNode.ARRAY_ACCESS, new ArrayAccessInferenceStrategy(this, ppaEngine)); strategies.put(ASTNode.PREFIX_EXPRESSION, new PrefixInferenceStrategy(this, ppaEngine)); strategies.put(ASTNode.POSTFIX_EXPRESSION, new PostfixInferenceStrategy(this, ppaEngine)); strategies.put(ASTNode.CLASS_INSTANCE_CREATION, new ConstructorInferenceStrategy(this, ppaEngine)); }
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 w w . j ava2s . c o m } return true; }
From source file:com.crispico.flower.mp.metamodel.codesyncjava.algorithm.JavaSyncUtils.java
License:Open Source License
/** * Generates a body for method and inserts a comment at first line in the body content. * <p>//from w ww. j a va 2 s . c om * Comments aren't created as child nodes if we parse a block string that contains comment lines. <br> * Hack made : <br> * <ul> * <li>a new {@link Statement} is created and added to block node. Because we can't create comments as {@link ASTNode} * the statement is created as a {@link ReturnStatement}. * <li>the statement will contain the comment code * <li>because the return statement node created must return our code (and not return;), * it must be stored in NodeInfoStore class found as private field in InternalASTRewrite found as private field in the root AST class. * * <li>when {@link JavaSyncUtils#writeJavafile(CompilationUnit, IFile)} is called at the end of forward mechanism * it invokes {@link CompilationUnit#rewrite(org.eclipse.jface.text.IDocument, java.util.Map)} that will replace the * return statement code with our code based on what it finds in NodeInfoStore list. * </ul> * @param md - the {@link MethodDeclaration} that requires a new body block. * @param blockString - the {@link String} that will form the block content. * @param commentString - the {@link String} that will form the line comment. * * @author Cristina */ @SuppressWarnings("unchecked") public static void generateBodyWithCommentForMethod(MethodDeclaration md, String blockString, String commentString) { // generate body content without comments generateBodyForMethod(md, blockString); // insert comment on first line try { // get rewriter field from AST Object rewriter = FlowerMPUtils.getPrivateField(AST.class, "rewriter", md.getRoot().getAST()); Class<?> thisClass = Class.forName("org.eclipse.jdt.core.dom.InternalASTRewrite"); // get nodeStore field from InternalASTRewrite Object nodestore = FlowerMPUtils.getPrivateField(thisClass, "nodeStore", rewriter); Class<?> nodeInfoStore = Class.forName("org.eclipse.jdt.internal.core.dom.rewrite.NodeInfoStore"); // nodeStore.newPlaceholderNode(ASTNode.RETURN_STATEMENT) Method newPlaceholderNode = nodeInfoStore.getDeclaredMethod("newPlaceholderNode", int.class); ASTNode placeholder = (ASTNode) newPlaceholderNode.invoke(nodestore, ASTNode.RETURN_STATEMENT); // nodestore.markAsStringPlaceholder(placeholder, commentString) Method markAsStringPlaceholder = nodeInfoStore.getDeclaredMethod("markAsStringPlaceholder", ASTNode.class, String.class); markAsStringPlaceholder.invoke(nodestore, placeholder, commentString); // add comment to body content md.getBody().statements().add(0, placeholder); } catch (Exception e) { // swallowed } }
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 ww. jav 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 ww w.ja va2s.c o 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:/*from w ww. j a va2s.c om*/ throw new AssertionError("Unknown node type: " + jdtNode.getClass().getName()); } }
From source file:edu.cmu.cs.crystal.internal.ControlFlowNode.java
License:Open Source License
/** * A recursive method for correcting the structure of a CFG * in the context of a return statement. After this method * completes, the return statement will be properly connected * to the methodDeclaration.//from w ww . ja va 2 s . co m * @return the methodDeclaration to return to */ public ControlFlowNode returning() { ControlFlowNode cfn = getNode(Direction.FORWARDS); ControlFlowNode resultCFN; if (cfn.astNode.getNodeType() != ASTNode.METHOD_DECLARATION) { int size = cfn.getNumberOfEdges(Direction.BACKWARDS); if (size == 0) throw new CrystalRuntimeException("one way edge detected"); else if (size == 1) { resultCFN = cfn.returning(); cfn.remove(); } else resultCFN = cfn.findNode(Direction.FORWARDS, ASTNode.METHOD_DECLARATION); } else resultCFN = cfn; // If this is not the return statement, the unwind if (astNode.getNodeType() != ASTNode.RETURN_STATEMENT) return resultCFN; // Make sure we found the method we are returning from if (resultCFN == null || resultCFN.astNode.getNodeType() != ASTNode.METHOD_DECLARATION) throw new CrystalRuntimeException("could not find method declaration to return from"); // If return is already hooked up to the method then nothing to do if (resultCFN == cfn) return cfn; // Disconnect the return and reconnect to the method declaration removeEdges(Direction.FORWARDS); addEdge(Direction.FORWARDS, resultCFN); return resultCFN; }
From source file:jmockit.assist.MockMethodCompletionProposal.java
License:Open Source License
@SuppressWarnings("unchecked") private void setReturnStatement(final MethodDeclaration stub, final IMethodBinding methodToOverride, final ITypeBinding declaringType, final AST ast, final ASTRewrite rewrite) throws JavaModelException, CoreException { Expression expression = ASTNodeFactory.newDefaultExpression(ast, stub.getReturnType2(), stub.getExtraDimensions());/* w w w . ja v a 2s.co m*/ if (expression != null) { ReturnStatement returnStatement = ast.newReturnStatement(); returnStatement.setExpression(expression); String delimiter = cunit.findRecommendedLineSeparator(); Map<String, String> options = fJavaProject.getOptions(true); String bodyStatement = ASTNodes.asFormattedString(returnStatement, 0, delimiter, options); String placeHolder = CodeGeneration.getMethodBodyContent(cunit, declaringType.getName(), methodToOverride.getName(), false, bodyStatement, delimiter); if (placeHolder != null) { ASTNode todoNode = rewrite.createStringPlaceholder(placeHolder, ASTNode.RETURN_STATEMENT); stub.getBody().statements().clear(); stub.getBody().statements().add(todoNode); } } }
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 ww w . j ava 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.autorefactor.refactoring.rules.RecycleRefactoring.java
License:Open Source License
@Override public boolean visit(MethodInvocation node) { final ASTBuilder b = this.ctx.getASTBuilder(); final Refactorings r = this.ctx.getRefactorings(); String recycleMethodName = methodNameToCleanupResource(node); if (recycleMethodName != null) { SimpleName cursorExpression = null; ASTNode variableAssignmentNode = null; VariableDeclarationFragment variableDeclarationFragment = (VariableDeclarationFragment) ASTNodes .getParent(node, ASTNode.VARIABLE_DECLARATION_FRAGMENT); if (variableDeclarationFragment != null) { cursorExpression = variableDeclarationFragment.getName(); variableAssignmentNode = variableDeclarationFragment; } else {// ww w. j ava 2 s .c om Assignment variableAssignment = (Assignment) ASTNodes.getParent(node, ASTNode.ASSIGNMENT); cursorExpression = (SimpleName) variableAssignment.getLeftHandSide(); variableAssignmentNode = variableAssignment; } // Check whether it has been closed ClosePresenceChecker closePresenceChecker = new ClosePresenceChecker(cursorExpression, recycleMethodName); VisitorDecorator visitor = new VisitorDecorator(variableAssignmentNode, cursorExpression, closePresenceChecker); Block block = (Block) ASTNodes.getParent(node, ASTNode.BLOCK); block.accept(visitor); if (!closePresenceChecker.closePresent) { MethodInvocation closeInvocation = b.getAST().newMethodInvocation(); closeInvocation.setName(b.simpleName(recycleMethodName)); closeInvocation.setExpression(b.copy(cursorExpression)); ExpressionStatement expressionStatement = b.getAST().newExpressionStatement(closeInvocation); Statement lastCursorAccess = closePresenceChecker.getLastCursorStatementInBlock(block); if (lastCursorAccess.getNodeType() != ASTNode.RETURN_STATEMENT) { r.insertAfter(expressionStatement, lastCursorAccess); return DO_NOT_VISIT_SUBTREE; } } } return VISIT_SUBTREE; }