List of usage examples for org.eclipse.jdt.core.dom ASTNode STRING_LITERAL
int STRING_LITERAL
To view the source code for org.eclipse.jdt.core.dom ASTNode STRING_LITERAL.
Click Source Link
StringLiteral. From source file:ch.acanda.eclipse.pmd.java.resolution.optimization.AddEmptyStringQuickFix.java
License:Open Source License
private boolean isStringLiteral(final Expression expression) { return expression.getNodeType() == ASTNode.STRING_LITERAL; }
From source file:com.android.ide.eclipse.adt.internal.editors.layout.refactoring.JavaQuickAssistant.java
License:Open Source License
@Override public IJavaCompletionProposal[] getAssists(IInvocationContext context, IProblemLocation[] locations) throws CoreException { // We should only offer Android quick assists within Android projects. // This can be done by adding this logic to the extension registration: ///* w w w .j a v a 2 s .co m*/ // <enablement> // <with variable="projectNatures"> // <iterate operator="or"> // <equals value="com.android.ide.eclipse.adt.AndroidNature"/> // </iterate> // </with> // </enablement> // // However, this causes some errors to be dumped to the log, so instead we filter // out non Android projects programmatically: IProject project = context.getCompilationUnit().getJavaProject().getProject(); if (project == null || !BaseProjectHelper.isAndroidProject(project)) { return null; } ASTNode coveringNode = context.getCoveringNode(); if (coveringNode != null && coveringNode.getNodeType() == ASTNode.STRING_LITERAL && coveringNode.getLength() > 2) { // don't extract empty strings (includes quotes) return new IJavaCompletionProposal[] { new ExtractStringProposal(context) }; } return null; }
From source file:com.android.ide.eclipse.auidt.internal.editors.layout.refactoring.JavaQuickAssistant.java
License:Open Source License
@Override public IJavaCompletionProposal[] getAssists(IInvocationContext context, IProblemLocation[] locations) throws CoreException { // We should only offer Android quick assists within Android projects. // This can be done by adding this logic to the extension registration: ////from w w w . j av a 2 s. c o m // <enablement> // <with variable="projectNatures"> // <iterate operator="or"> // <equals value="com.android.ide.eclipse.auidt.AndroidNature"/> // </iterate> // </with> // </enablement> // // However, this causes some errors to be dumped to the log, so instead we filter // out non Android projects programmatically: IProject project = context.getCompilationUnit().getJavaProject().getProject(); if (project == null || !BaseProjectHelper.isAndroidProject(project)) { return null; } ASTNode coveringNode = context.getCoveringNode(); if (coveringNode != null && coveringNode.getNodeType() == ASTNode.STRING_LITERAL && coveringNode.getLength() > 2) { // don't extract empty strings (includes quotes) return new IJavaCompletionProposal[] { new ExtractStringProposal(context) }; } return null; }
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 ww w. j a va 2s. c o m*/ throw new AssertionError("Unknown node type: " + jdtNode.getClass().getName()); } }
From source file:com.google.devtools.j2objc.jdt.TreeConverter.java
License:Apache License
private static TreeNode convertInner(ASTNode jdtNode) { switch (jdtNode.getNodeType()) { case ASTNode.ANNOTATION_TYPE_DECLARATION: return convertAnnotationTypeDeclaration((org.eclipse.jdt.core.dom.AnnotationTypeDeclaration) jdtNode); case ASTNode.ANNOTATION_TYPE_MEMBER_DECLARATION: return convertAnnotationTypeMemberDeclaration( (org.eclipse.jdt.core.dom.AnnotationTypeMemberDeclaration) jdtNode); case ASTNode.ARRAY_ACCESS: return convertArrayAccess((org.eclipse.jdt.core.dom.ArrayAccess) jdtNode); case ASTNode.ARRAY_CREATION: return convertArrayCreation((org.eclipse.jdt.core.dom.ArrayCreation) jdtNode); case ASTNode.ARRAY_INITIALIZER: return convertArrayInitializer((org.eclipse.jdt.core.dom.ArrayInitializer) jdtNode); case ASTNode.ARRAY_TYPE: return convertArrayType((org.eclipse.jdt.core.dom.ArrayType) jdtNode); case ASTNode.ASSERT_STATEMENT: return convertAssertStatement((org.eclipse.jdt.core.dom.AssertStatement) jdtNode); case ASTNode.ASSIGNMENT: return convertAssignment((org.eclipse.jdt.core.dom.Assignment) jdtNode); case ASTNode.BLOCK: return convertBlock((org.eclipse.jdt.core.dom.Block) jdtNode); case ASTNode.BLOCK_COMMENT: return new BlockComment(); case ASTNode.BOOLEAN_LITERAL: return convertBooleanLiteral((org.eclipse.jdt.core.dom.BooleanLiteral) jdtNode); case ASTNode.BREAK_STATEMENT: return convertBreakStatement((org.eclipse.jdt.core.dom.BreakStatement) jdtNode); case ASTNode.CAST_EXPRESSION: return convertCastExpression((org.eclipse.jdt.core.dom.CastExpression) jdtNode); case ASTNode.CATCH_CLAUSE: return convertCatchClause((org.eclipse.jdt.core.dom.CatchClause) jdtNode); case ASTNode.CHARACTER_LITERAL: return convertCharacterLiteral((org.eclipse.jdt.core.dom.CharacterLiteral) jdtNode); case ASTNode.CLASS_INSTANCE_CREATION: return convertClassInstanceCreation((org.eclipse.jdt.core.dom.ClassInstanceCreation) jdtNode); case ASTNode.CONDITIONAL_EXPRESSION: return convertConditionalExpression((org.eclipse.jdt.core.dom.ConditionalExpression) jdtNode); case ASTNode.CONSTRUCTOR_INVOCATION: return convertConstructorInvocation((org.eclipse.jdt.core.dom.ConstructorInvocation) jdtNode); case ASTNode.CONTINUE_STATEMENT: return convertContinueStatement((org.eclipse.jdt.core.dom.ContinueStatement) jdtNode); case ASTNode.CREATION_REFERENCE: return convertCreationReference((org.eclipse.jdt.core.dom.CreationReference) jdtNode); case ASTNode.DIMENSION: return convertDimension((org.eclipse.jdt.core.dom.Dimension) jdtNode); case ASTNode.DO_STATEMENT: return convertDoStatement((org.eclipse.jdt.core.dom.DoStatement) jdtNode); case ASTNode.EMPTY_STATEMENT: return new EmptyStatement(); case ASTNode.ENHANCED_FOR_STATEMENT: return convertEnhancedForStatement((org.eclipse.jdt.core.dom.EnhancedForStatement) jdtNode); case ASTNode.ENUM_CONSTANT_DECLARATION: return convertEnumConstantDeclaration((org.eclipse.jdt.core.dom.EnumConstantDeclaration) jdtNode); case ASTNode.ENUM_DECLARATION: return convertEnumDeclaration((org.eclipse.jdt.core.dom.EnumDeclaration) jdtNode); case ASTNode.EXPRESSION_METHOD_REFERENCE: return convertExpressionMethodReference((org.eclipse.jdt.core.dom.ExpressionMethodReference) jdtNode); case ASTNode.EXPRESSION_STATEMENT: return convertExpressionStatement((org.eclipse.jdt.core.dom.ExpressionStatement) jdtNode); case ASTNode.FIELD_ACCESS: return convertFieldAccess((org.eclipse.jdt.core.dom.FieldAccess) jdtNode); case ASTNode.FIELD_DECLARATION: return convertFieldDeclaration((org.eclipse.jdt.core.dom.FieldDeclaration) jdtNode); case ASTNode.FOR_STATEMENT: return convertForStatement((org.eclipse.jdt.core.dom.ForStatement) jdtNode); case ASTNode.IF_STATEMENT: return convertIfStatement((org.eclipse.jdt.core.dom.IfStatement) jdtNode); case ASTNode.INFIX_EXPRESSION: return convertInfixExpression((org.eclipse.jdt.core.dom.InfixExpression) jdtNode); case ASTNode.INTERSECTION_TYPE: return convertIntersectionType((org.eclipse.jdt.core.dom.IntersectionType) jdtNode); case ASTNode.INITIALIZER: return convertInitializer((org.eclipse.jdt.core.dom.Initializer) jdtNode); case ASTNode.INSTANCEOF_EXPRESSION: return convertInstanceofExpression((org.eclipse.jdt.core.dom.InstanceofExpression) jdtNode); case ASTNode.JAVADOC: return convertJavadoc((org.eclipse.jdt.core.dom.Javadoc) jdtNode); case ASTNode.LABELED_STATEMENT: return convertLabeledStatement((org.eclipse.jdt.core.dom.LabeledStatement) jdtNode); case ASTNode.LAMBDA_EXPRESSION: return convertLambdaExpression((org.eclipse.jdt.core.dom.LambdaExpression) jdtNode); case ASTNode.LINE_COMMENT: return new LineComment(); case ASTNode.MARKER_ANNOTATION: return convertMarkerAnnotation((org.eclipse.jdt.core.dom.MarkerAnnotation) jdtNode); case ASTNode.MEMBER_VALUE_PAIR: return convertMemberValuePair((org.eclipse.jdt.core.dom.MemberValuePair) jdtNode); case ASTNode.METHOD_DECLARATION: return convertMethodDeclaration((org.eclipse.jdt.core.dom.MethodDeclaration) jdtNode); case ASTNode.METHOD_INVOCATION: return convertMethodInvocation((org.eclipse.jdt.core.dom.MethodInvocation) jdtNode); case ASTNode.NAME_QUALIFIED_TYPE: return convertNameQualifiedType((org.eclipse.jdt.core.dom.NameQualifiedType) jdtNode); case ASTNode.NORMAL_ANNOTATION: return convertNormalAnnotation((org.eclipse.jdt.core.dom.NormalAnnotation) jdtNode); case ASTNode.NULL_LITERAL: return new NullLiteral(BindingConverter.NULL_TYPE); case ASTNode.NUMBER_LITERAL: return convertNumberLiteral((org.eclipse.jdt.core.dom.NumberLiteral) jdtNode); case ASTNode.PACKAGE_DECLARATION: return convertPackageDeclaration((org.eclipse.jdt.core.dom.PackageDeclaration) jdtNode); case ASTNode.PARAMETERIZED_TYPE: return convertParameterizedType((org.eclipse.jdt.core.dom.ParameterizedType) jdtNode); case ASTNode.PARENTHESIZED_EXPRESSION: return convertParenthesizedExpression((org.eclipse.jdt.core.dom.ParenthesizedExpression) jdtNode); case ASTNode.POSTFIX_EXPRESSION: return convertPostfixExpression((org.eclipse.jdt.core.dom.PostfixExpression) jdtNode); case ASTNode.PREFIX_EXPRESSION: return convertPrefixExpression((org.eclipse.jdt.core.dom.PrefixExpression) jdtNode); case ASTNode.PRIMITIVE_TYPE: return convertPrimitiveType((org.eclipse.jdt.core.dom.PrimitiveType) jdtNode); case ASTNode.QUALIFIED_NAME: return convertQualifiedName((org.eclipse.jdt.core.dom.QualifiedName) jdtNode); case ASTNode.QUALIFIED_TYPE: return convertQualifiedType((org.eclipse.jdt.core.dom.QualifiedType) jdtNode); case ASTNode.RETURN_STATEMENT: return convertReturnStatement((org.eclipse.jdt.core.dom.ReturnStatement) jdtNode); case ASTNode.SIMPLE_NAME: return convertSimpleName((org.eclipse.jdt.core.dom.SimpleName) jdtNode); case ASTNode.SIMPLE_TYPE: return convertSimpleType((org.eclipse.jdt.core.dom.SimpleType) jdtNode); case ASTNode.SINGLE_MEMBER_ANNOTATION: return convertSingleMemberAnnotation((org.eclipse.jdt.core.dom.SingleMemberAnnotation) jdtNode); case ASTNode.SINGLE_VARIABLE_DECLARATION: return convertSingleVariableDeclaration((org.eclipse.jdt.core.dom.SingleVariableDeclaration) jdtNode); case ASTNode.STRING_LITERAL: return convertStringLiteral((org.eclipse.jdt.core.dom.StringLiteral) jdtNode); case ASTNode.SUPER_CONSTRUCTOR_INVOCATION: return convertSuperConstructorInvocation((org.eclipse.jdt.core.dom.SuperConstructorInvocation) jdtNode); case ASTNode.SUPER_FIELD_ACCESS: return convertSuperFieldAccess((org.eclipse.jdt.core.dom.SuperFieldAccess) jdtNode); case ASTNode.SUPER_METHOD_INVOCATION: return convertSuperMethodInvocation((org.eclipse.jdt.core.dom.SuperMethodInvocation) jdtNode); case ASTNode.SUPER_METHOD_REFERENCE: return convertSuperMethodReference((org.eclipse.jdt.core.dom.SuperMethodReference) jdtNode); case ASTNode.SWITCH_CASE: return convertSwitchCase((org.eclipse.jdt.core.dom.SwitchCase) jdtNode); case ASTNode.SWITCH_STATEMENT: return convertSwitchStatement((org.eclipse.jdt.core.dom.SwitchStatement) jdtNode); case ASTNode.SYNCHRONIZED_STATEMENT: return convertSynchronizedStatement((org.eclipse.jdt.core.dom.SynchronizedStatement) jdtNode); case ASTNode.TAG_ELEMENT: return convertTagElement((org.eclipse.jdt.core.dom.TagElement) jdtNode); case ASTNode.TEXT_ELEMENT: return convertTextElement(((org.eclipse.jdt.core.dom.TextElement) jdtNode).getText()); case ASTNode.THIS_EXPRESSION: return convertThisExpression((org.eclipse.jdt.core.dom.ThisExpression) jdtNode); case ASTNode.THROW_STATEMENT: return convertThrowStatement((org.eclipse.jdt.core.dom.ThrowStatement) jdtNode); case ASTNode.TRY_STATEMENT: return convertTryStatement((org.eclipse.jdt.core.dom.TryStatement) jdtNode); case ASTNode.TYPE_DECLARATION: return convertTypeDeclaration((org.eclipse.jdt.core.dom.TypeDeclaration) jdtNode); case ASTNode.TYPE_DECLARATION_STATEMENT: return convertTypeDeclarationStatement((org.eclipse.jdt.core.dom.TypeDeclarationStatement) jdtNode); case ASTNode.TYPE_LITERAL: return convertTypeLiteral((org.eclipse.jdt.core.dom.TypeLiteral) jdtNode); case ASTNode.TYPE_METHOD_REFERENCE: return convertTypeMethodReference((org.eclipse.jdt.core.dom.TypeMethodReference) jdtNode); case ASTNode.UNION_TYPE: return convertUnionType((org.eclipse.jdt.core.dom.UnionType) jdtNode); case ASTNode.VARIABLE_DECLARATION_EXPRESSION: return convertVariableDeclarationExpression( (org.eclipse.jdt.core.dom.VariableDeclarationExpression) jdtNode); case ASTNode.VARIABLE_DECLARATION_FRAGMENT: return convertVariableDeclarationFragment( (org.eclipse.jdt.core.dom.VariableDeclarationFragment) jdtNode); case ASTNode.VARIABLE_DECLARATION_STATEMENT: return convertVariableDeclarationStatement( (org.eclipse.jdt.core.dom.VariableDeclarationStatement) jdtNode); case ASTNode.WHILE_STATEMENT: return convertWhileStatement((org.eclipse.jdt.core.dom.WhileStatement) jdtNode); // These nodes only appear in comments and J2ObjC doens't need any // information from their subtree so we just convert them to TextElement. case ASTNode.MEMBER_REF: case ASTNode.METHOD_REF: case ASTNode.METHOD_REF_PARAMETER: return convertTextElement(jdtNode.toString()); case ASTNode.COMPILATION_UNIT: throw new AssertionError("CompilationUnit must be converted using convertCompilationUnit()"); default://from ww w. j a v a2 s . c o m throw new AssertionError("Unknown node type: " + jdtNode.getClass().getName()); } }
From source file:com.google.gdt.eclipse.core.JavaASTUtils.java
License:Open Source License
@SuppressWarnings("unchecked") private static boolean containsAnnotationValue(Expression annotationValue, String value) { if (annotationValue.getNodeType() == ASTNode.STRING_LITERAL) { String valueString = ((StringLiteral) annotationValue).getLiteralValue(); return value.equals(valueString); } else if (annotationValue.getNodeType() == ASTNode.ARRAY_INITIALIZER) { // If the annotation value is actually an array, check each element List<Expression> warningTypes = ((ArrayInitializer) annotationValue).expressions(); for (Expression warningType : warningTypes) { if (containsAnnotationValue(warningType, value)) { return true; }// w w w .ja va2s.c om } } return false; }
From source file:com.halware.nakedide.eclipse.ext.annot.utils.AstUtils.java
License:Open Source License
public static Object getValue(ASTNode node) { switch (node.getNodeType()) { // case ASTNode.ANONYMOUS_CLASS_DECLARATION: // return "Anonymous class declaration"; // case ASTNode.ARRAY_ACCESS: // return "Array access"; // case ASTNode.ARRAY_CREATION: // return "Array creation"; // case ASTNode.ARRAY_INITIALIZER: // return "Array initializer"; // case ASTNode.ARRAY_TYPE: // ArrayType arrayType = (ArrayType)node; // return "Array type: " + arrayType.getElementType().toString(); // case ASTNode.ASSERT_STATEMENT: // return "Assert statement"; // case ASTNode.ASSIGNMENT: // return "Assignment"; // case ASTNode.BLOCK: // return "Block"; case ASTNode.BOOLEAN_LITERAL: BooleanLiteral booleanLiteral = (BooleanLiteral) node; return booleanLiteral.booleanValue(); // case ASTNode.BREAK_STATEMENT: // return "Break statement"; // case ASTNode.CAST_EXPRESSION: // return "Cast expression"; // case ASTNode.CATCH_CLAUSE: // return "Catch clause"; case ASTNode.CHARACTER_LITERAL: CharacterLiteral characterLiteral = (CharacterLiteral) node; return characterLiteral.charValue(); // case ASTNode.CLASS_INSTANCE_CREATION: // return "Class instance creation"; // case ASTNode.COMPILATION_UNIT: // return "Compilation unit"; // case ASTNode.CONDITIONAL_EXPRESSION: // return "Conditional Expression"; // case ASTNode.CONSTRUCTOR_INVOCATION: // return "constructor invocation"; // case ASTNode.CONTINUE_STATEMENT: // return "continue statement"; // case ASTNode.DO_STATEMENT: // return "Do statement"; // case ASTNode.EMPTY_STATEMENT: // return "Empty statement"; // case ASTNode.EXPRESSION_STATEMENT: // return "Expression statement"; // case ASTNode.FIELD_ACCESS: // return "field access"; // case ASTNode.FIELD_DECLARATION: // return "Field declaration"; // case ASTNode.FOR_STATEMENT: // return "For statement"; // case ASTNode.IF_STATEMENT: // return "If statement"; // case ASTNode.IMPORT_DECLARATION: // return "Import declaration"; // case ASTNode.INFIX_EXPRESSION: // return "Infix expression"; // case ASTNode.INITIALIZER: // return "Initializer"; // case ASTNode.INSTANCEOF_EXPRESSION: // return "Instanceof expression"; // case ASTNode.JAVADOC: // return "Javadoc"; // case ASTNode.LABELED_STATEMENT: // return "Labeled statement"; // case ASTNode.METHOD_DECLARATION: // return "Method declaration"; // case ASTNode.METHOD_INVOCATION: // return "Method invocation"; // case ASTNode.NULL_LITERAL: // return "Null literal"; case ASTNode.NUMBER_LITERAL: NumberLiteral numberLiteral = (NumberLiteral) node; String token = numberLiteral.getToken(); try {/*from w w w. j av a 2 s. co m*/ return Integer.parseInt(token); } catch (Exception ex) { } try { return Long.parseLong(token); } catch (Exception ex) { } try { return Double.parseDouble(token); } catch (Exception ex) { } try { return Float.parseFloat(token); } catch (Exception ex) { } return Double.NaN; // case ASTNode.PACKAGE_DECLARATION: // return "Package declaration"; // case ASTNode.PARENTHESIZED_EXPRESSION: // return "Parenthesized expression"; // case ASTNode.POSTFIX_EXPRESSION: // return "Postfix expression"; // case ASTNode.PREFIX_EXPRESSION: // return "Prefix expression"; // case ASTNode.PRIMITIVE_TYPE: // PrimitiveType primitiveType = (PrimitiveType) node; // return "Primitive type: " + primitiveType.getPrimitiveTypeCode().toString(); case ASTNode.QUALIFIED_NAME: QualifiedName qualifiedName = (QualifiedName) node; return new AstUtils.QualifiedNameValue(qualifiedName.getQualifier().getFullyQualifiedName(), qualifiedName.getName().getIdentifier()); // case ASTNode.RETURN_STATEMENT: // return "Return statement"; // case ASTNode.SIMPLE_NAME: // SimpleName simpleName = (SimpleName) node; // return "Simple name: " + simpleName.getIdentifier(); // case ASTNode.SIMPLE_TYPE: // SimpleType simpleType = (SimpleType) node; // return "Simple type (" + simpleType.getName().toString() + ")"; // case ASTNode.SINGLE_VARIABLE_DECLARATION: // return "Single variable declaration"; case ASTNode.STRING_LITERAL: StringLiteral stringLiteral = (StringLiteral) node; return stringLiteral.getLiteralValue(); // case ASTNode.SUPER_CONSTRUCTOR_INVOCATION: // return "Super constructor invocation"; // case ASTNode.SUPER_FIELD_ACCESS: // return "Super field access"; // case ASTNode.SUPER_METHOD_INVOCATION: // return "Super method invocation"; // case ASTNode.SWITCH_CASE: // return "Switch case"; // case ASTNode.SWITCH_STATEMENT: // return "Switch statement"; // case ASTNode.SYNCHRONIZED_STATEMENT: // return "Synchronized statement"; // case ASTNode.THIS_EXPRESSION: // return "This expression"; // case ASTNode.THROW_STATEMENT: // return "Throw statement"; // case ASTNode.TRY_STATEMENT: // return "Try statement"; // case ASTNode.TYPE_DECLARATION: // return "Type declaration"; // case ASTNode.TYPE_DECLARATION_STATEMENT: // return "Type declaration statement"; case ASTNode.TYPE_LITERAL: TypeLiteral typeLiteral = (TypeLiteral) node; return new AstUtils.TypeLiteralValue(typeLiteral.toString()); // case ASTNode.VARIABLE_DECLARATION_EXPRESSION: // return "Varialbe declaration expression"; // case ASTNode.VARIABLE_DECLARATION_FRAGMENT: // return "Variable declaration fragment"; // case ASTNode.VARIABLE_DECLARATION_STATEMENT: // return "Variable declaration statement"; // case ASTNode.WHILE_STATEMENT: // return "While statement"; } return null; }
From source file:com.halware.nakedide.eclipse.ext.annot.utils.dali.ASTTools.java
License:Open Source License
public static String stringValue(Expression expression) { if (expression.getNodeType() == ASTNode.STRING_LITERAL) { return ((StringLiteral) expression).getLiteralValue(); }/*from w ww .j a v a 2 s .c o m*/ return null; }
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 w w . jav a 2s. co m throw new AssertionError("Unknown node type: " + jdtNode.getClass().getName()); } }
From source file:egovframework.mgt.fit.library.parser.visitor.MethodParsingVisitor.java
License:Apache License
/** * ? ? ? ./* w ww . j a va 2 s.co 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()); }