@Override public int getStartPosition() { return method.getStartPosition(); }
@Override public boolean visit(MethodDeclaration aNode) { new de.tudarmstadt.ukp.teaching.uima.lesson2.type.MethodDeclaration(jcas, aNode .getStartPosition(), aNode.getStartPosition() + aNode.getLength()).addToIndexes(); return false; } }
@Override public boolean visit(MethodDeclaration node) { String signature= getSignature(node); push(node.isConstructor() ? JavaNode.CONSTRUCTOR : JavaNode.METHOD, signature, node.getStartPosition(), node.getLength()); return false; }
@Override public boolean visit(MethodDeclaration node) { String signature= getSignature(node); push(node.isConstructor() ? JavaNode.CONSTRUCTOR : JavaNode.METHOD, signature, node.getStartPosition(), node.getLength()); return false; }
public boolean visit(MethodDeclaration node) { String signature= getSignature(node); push(node.isConstructor() ? JavaNode.CONSTRUCTOR : JavaNode.METHOD, signature, node.getStartPosition(), node.getLength()); return false; }
private CFGBasicBlock newExitBlock(MethodDeclaration node) { final LineAndColumn lineCol = getLineAndColumn(node .getStartPosition() + node.getLength()); return CFGBasicBlock.buildExitBlock(node, getFileName(node), codeExcerpt(node), lineCol); }
public Expression createDefaultExpression(List invocationArguments, ParameterInfo addedInfo, List parameterInfos, MethodDeclaration enclosingMethod, boolean isRecursive, CompilationUnitRewrite cuRewrite) { final AST ast= cuRewrite.getAST(); final ASTRewrite rewrite= cuRewrite.getASTRewrite(); if (isRecursive && canReuseParameterObject(invocationArguments, addedInfo, parameterInfos, enclosingMethod)) { return ast.newSimpleName(addedInfo.getNewName()); } ClassInstanceCreation classCreation= ast.newClassInstanceCreation(); int startPosition= enclosingMethod != null ? enclosingMethod.getStartPosition() : cuRewrite.getRoot().getStartPosition(); classCreation.setType(fParameterObjectFactory.createType(fCreateAsTopLevel, cuRewrite, startPosition)); List constructorArguments= classCreation.arguments(); for (Iterator iter= parameterInfos.iterator(); iter.hasNext();) { ParameterInfo pi= (ParameterInfo) iter.next(); if (isValidField(pi)) { if (pi.isOldVarargs()) { boolean isLastParameter= !iter.hasNext(); constructorArguments.addAll(computeVarargs(invocationArguments, pi, isLastParameter, cuRewrite)); } else { Expression exp= (Expression) invocationArguments.get(pi.getOldIndex()); importNodeTypes(exp, cuRewrite); constructorArguments.add(moveNode(exp, rewrite)); } } } return classCreation; }
@Override public Expression createDefaultExpression(List<Expression> invocationArguments, ParameterInfo addedInfo, List<ParameterInfo> parameterInfos, MethodDeclaration enclosingMethod, boolean isRecursive, CompilationUnitRewrite cuRewrite) { final AST ast= cuRewrite.getAST(); final ASTRewrite rewrite= cuRewrite.getASTRewrite(); if (isRecursive && canReuseParameterObject(invocationArguments, addedInfo, parameterInfos, enclosingMethod)) { return ast.newSimpleName(addedInfo.getNewName()); } ClassInstanceCreation classCreation= ast.newClassInstanceCreation(); int startPosition= enclosingMethod != null ? enclosingMethod.getStartPosition() : cuRewrite.getRoot().getStartPosition(); ContextSensitiveImportRewriteContext context= fParameterObjectFactory.createParameterClassAwareContext(fCreateAsTopLevel, cuRewrite, startPosition); classCreation.setType(fParameterObjectFactory.createType(fCreateAsTopLevel, cuRewrite, startPosition)); List<Expression> constructorArguments= classCreation.arguments(); for (Iterator<ParameterInfo> iter= parameterInfos.iterator(); iter.hasNext();) { ParameterInfo pi= iter.next(); if (isValidField(pi)) { if (pi.isOldVarargs()) { boolean isLastParameter= !iter.hasNext(); constructorArguments.addAll(computeVarargs(invocationArguments, pi, isLastParameter, cuRewrite, context)); } else { Expression exp= invocationArguments.get(pi.getOldIndex()); importNodeTypes(exp, cuRewrite, context); constructorArguments.add(moveNode(exp, rewrite)); } } } return classCreation; }
@Override public Expression createDefaultExpression(List<Expression> invocationArguments, ParameterInfo addedInfo, List<ParameterInfo> parameterInfos, MethodDeclaration enclosingMethod, boolean isRecursive, CompilationUnitRewrite cuRewrite) { final AST ast= cuRewrite.getAST(); final ASTRewrite rewrite= cuRewrite.getASTRewrite(); if (isRecursive && canReuseParameterObject(invocationArguments, addedInfo, parameterInfos, enclosingMethod)) { return ast.newSimpleName(addedInfo.getNewName()); } ClassInstanceCreation classCreation= ast.newClassInstanceCreation(); int startPosition= enclosingMethod != null ? enclosingMethod.getStartPosition() : cuRewrite.getRoot().getStartPosition(); ContextSensitiveImportRewriteContext context= fParameterObjectFactory.createParameterClassAwareContext(fCreateAsTopLevel, cuRewrite, startPosition); classCreation.setType(fParameterObjectFactory.createType(fCreateAsTopLevel, cuRewrite, startPosition)); List<Expression> constructorArguments= classCreation.arguments(); for (Iterator<ParameterInfo> iter= parameterInfos.iterator(); iter.hasNext();) { ParameterInfo pi= iter.next(); if (isValidField(pi)) { if (pi.isOldVarargs()) { boolean isLastParameter= !iter.hasNext(); constructorArguments.addAll(computeVarargs(invocationArguments, pi, isLastParameter, cuRewrite, context)); } else { Expression exp= invocationArguments.get(pi.getOldIndex()); importNodeTypes(exp, cuRewrite, context); constructorArguments.add(moveNode(exp, rewrite)); } } } return classCreation; }
@Override public boolean visit(MethodDeclaration node) { // get a method's return type. Type returnType = node.getReturnType2(); if (returnType != null) { processType(returnType, "Return type", SourceType.TYPE); } List<SingleVariableDeclaration> parameters = (List<SingleVariableDeclaration>) node.parameters(); if (parameters != null) { for (SingleVariableDeclaration type : parameters) { // make it fully qualified. String typeName = type.getType().toString(); if (classNameToFullyQualified.containsKey(typeName)) { typeName = classNameToFullyQualified.get(typeName); } // now add it as a local variable. this.names.add(type.getName().toString()); this.nameInstance.put(type.getName().toString(), typeName); processType(type.getType(), "Method parameter", SourceType.TYPE); } } List<Name> throwsTypes = node.thrownExceptions(); if (throwsTypes != null) { for (Name name : throwsTypes) { processName(name, "Throws", node.getStartPosition()); } } return true; }
private void markReferences() { fCaughtExceptions= new ArrayList<>(); boolean isVoid= true; Type returnType= fMethodDeclaration.getReturnType2(); if (returnType != null) { ITypeBinding returnTypeBinding= returnType.resolveBinding(); isVoid= returnTypeBinding != null && Bindings.isVoidType(returnTypeBinding); } fMethodDeclaration.accept(this); Block block= fMethodDeclaration.getBody(); if (block != null) { List<Statement> statements= block.statements(); if (statements.size() > 0) { Statement last= statements.get(statements.size() - 1); int maxVariableId= LocalVariableIndex.perform(fMethodDeclaration); FlowContext flowContext= new FlowContext(0, maxVariableId + 1); flowContext.setConsiderAccessMode(false); flowContext.setComputeMode(FlowContext.ARGUMENTS); InOutFlowAnalyzer flowAnalyzer= new InOutFlowAnalyzer(flowContext); FlowInfo info= flowAnalyzer.perform(new ASTNode[] {last}); if (!info.isNoReturn() && !isVoid) { if (!info.isPartialReturn()) return; } } int offset= fMethodDeclaration.getStartPosition() + fMethodDeclaration.getLength() - 1; // closing bracket fResult.add(new OccurrenceLocation(offset, 1, 0, fExitDescription)); } }
private void markReferences() { fCatchedExceptions= new ArrayList(); boolean isVoid= true; Type returnType= fMethodDeclaration.getReturnType2(); if (returnType != null) { ITypeBinding returnTypeBinding= returnType.resolveBinding(); isVoid= returnTypeBinding != null && Bindings.isVoidType(returnTypeBinding); } fMethodDeclaration.accept(this); Block block= fMethodDeclaration.getBody(); if (block != null) { List statements= block.statements(); if (statements.size() > 0) { Statement last= (Statement)statements.get(statements.size() - 1); int maxVariableId= LocalVariableIndex.perform(fMethodDeclaration); FlowContext flowContext= new FlowContext(0, maxVariableId + 1); flowContext.setConsiderAccessMode(false); flowContext.setComputeMode(FlowContext.ARGUMENTS); InOutFlowAnalyzer flowAnalyzer= new InOutFlowAnalyzer(flowContext); FlowInfo info= flowAnalyzer.perform(new ASTNode[] {last}); if (!info.isNoReturn() && !isVoid) { if (!info.isPartialReturn()) return; } } SimpleName name= fAST.newSimpleName("x"); //$NON-NLS-1$ name.setSourceRange(fMethodDeclaration.getStartPosition() + fMethodDeclaration.getLength() - 1, 1); fResult.add(name); } }
@SuppressWarnings("unchecked") @Override public boolean visit(MethodDeclaration node) { if (importer.topOfContainerStack() instanceof Type) { IMethodBinding binding = node.resolveBinding(); Method method; if (binding != null) { method = importer.ensureMethodFromMethodBindingToCurrentContainer(binding); Arrays.stream(binding.getExceptionTypes()) .forEach(e -> importer.createDeclaredExceptionFromTypeBinding(e, method)); } else { logNullBinding("method declaration", node.getName(), ((CompilationUnit) node.getRoot()).getLineNumber(node.getStartPosition())); method = importer.ensureMethodFromMethodDeclaration(node); } method.setIsStub(false); method.setCyclomaticComplexity(1); importer.pushOnContainerStack(method); node.parameters().stream().forEach( p -> importer.ensureParameterFromSingleVariableDeclaration((SingleVariableDeclaration) p, method)); importer.createSourceAnchor(method, node); importer.createLightweightSourceAnchor(method, node.getName()); importer.ensureCommentFromBodyDeclaration(method, node); } return true; }
public static void createOverrideAnnotation(ASTRewrite rewrite, ImportRewrite imports, MethodDeclaration decl, TextEditGroup group) { if (findAnnotation("java.lang.Override", decl.modifiers()) != null) { //$NON-NLS-1$ return; // No need to add duplicate annotation } AST ast= rewrite.getAST(); ASTNode root= decl.getRoot(); ImportRewriteContext context= null; if (root instanceof CompilationUnit) { context= new ContextSensitiveImportRewriteContext((CompilationUnit) root, decl.getStartPosition(), imports); } Annotation marker= ast.newMarkerAnnotation(); marker.setTypeName(ast.newName(imports.addImport("java.lang.Override", context))); //$NON-NLS-1$ rewrite.getListRewrite(decl, MethodDeclaration.MODIFIERS2_PROPERTY).insertFirst(marker, group); }
public static void createOverrideAnnotation(ASTRewrite rewrite, ImportRewrite imports, MethodDeclaration decl, TextEditGroup group) { if (findAnnotation("java.lang.Override", decl.modifiers()) != null) { //$NON-NLS-1$ return; // No need to add duplicate annotation } AST ast= rewrite.getAST(); ASTNode root= decl.getRoot(); ImportRewriteContext context= null; if (root instanceof CompilationUnit) { context= new ContextSensitiveImportRewriteContext((CompilationUnit) root, decl.getStartPosition(), imports); } Annotation marker= ast.newMarkerAnnotation(); marker.setTypeName(ast.newName(imports.addImport("java.lang.Override", context))); //$NON-NLS-1$ rewrite.getListRewrite(decl, MethodDeclaration.MODIFIERS2_PROPERTY).insertFirst(marker, group); }
switch (event.getChangeKind()) { case RewriteEvent.INSERTED: { int endPos= parent.getStartPosition() + parent.getLength(); TextEditGroup editGroup= getEditGroup(event); ASTNode body= (ASTNode) event.getNewValue(); doTextRemove(startPos, endPos - startPos, editGroup); int indent= getIndent(parent.getStartPosition()); String prefix= this.formatter.METHOD_BODY.getPrefix(indent); doTextInsert(startPos, prefix, editGroup); TextEditGroup editGroup= getEditGroup(event); ASTNode body= (ASTNode) event.getOriginalValue(); int endPos= parent.getStartPosition() + parent.getLength(); doTextRemoveAndVisit(startPos, endPos - startPos, body, editGroup); doTextInsert(startPos, ";", editGroup); //$NON-NLS-1$
ASTNode clone0(AST target) { MethodDeclaration result = new MethodDeclaration(target); result.setSourceRange(getStartPosition(), getLength()); result.setJavadoc( (Javadoc) ASTNode.copySubtree(target, getJavadoc())); if (this.ast.apiLevel == AST.JLS2_INTERNAL) { result.internalSetModifiers(getModifiers()); result.setReturnType( (Type) ASTNode.copySubtree(target, getReturnType())); } if (this.ast.apiLevel >= AST.JLS3) { result.modifiers().addAll(ASTNode.copySubtrees(target, modifiers())); result.typeParameters().addAll( ASTNode.copySubtrees(target, typeParameters())); result.setReturnType2( (Type) ASTNode.copySubtree(target, getReturnType2())); } result.setConstructor(isConstructor()); result.setExtraDimensions(getExtraDimensions()); result.setName((SimpleName) getName().clone(target)); result.parameters().addAll( ASTNode.copySubtrees(target, parameters())); result.thrownExceptions().addAll( ASTNode.copySubtrees(target, thrownExceptions())); result.setBody( (Block) ASTNode.copySubtree(target, getBody())); return result; }
Assert.isNotNull(declaration); Assert.isNotNull(rewrite); final IRegion range= new Region(declaration.getStartPosition(), declaration.getLength()); final RangeMarker marker= new RangeMarker(range.getOffset(), range.getLength()); final IJavaProject project= fMethod.getJavaProject();
Assert.isNotNull(declaration); Assert.isNotNull(rewrite); final IRegion range= new Region(declaration.getStartPosition(), declaration.getLength()); final RangeMarker marker= new RangeMarker(range.getOffset(), range.getLength()); final IJavaProject project= fMethod.getJavaProject();
private void mapMethodParts(MethodDeclaration node, CSMethodBase method) { _currentType.addMember(method); method.startPosition(node.getStartPosition()); method.isVarArgs(node.isVarargs()); mapParameters(node, method); mapAnnotations(node, method); mapDocumentation(node, method); visitBodyDeclarationBlock(node, node.getBody(), method); IMethodBinding overriden = getOverridedMethod(node); if (!node.isConstructor() && overriden != null) { CSVisibility vis = mapVisibility (overriden.getModifiers()); if (vis == CSVisibility.ProtectedInternal && !overriden.getDeclaringClass().isFromSource()) vis = CSVisibility.Protected; method.visibility(vis); } else if (node.resolveBinding().getDeclaringClass().isInterface()) method.visibility(CSVisibility.Public); else mapVisibility(node, method); }