@Override public void visitCtImport(CtImport e) { if (e.getReference() != null) { scanCtReference(e.getReference()); } }
@SuppressWarnings("unchecked") @Override public <T, U> U getValue(T element) { return ((U) ((Object) (castTarget(element).getReference()))); }
@Override public void visitCtJavaDoc(CtJavaDoc ctJavaDoc) { StringBuilder stringBuilder = new StringBuilder(); stringBuilder.append(ctJavaDoc.getContent()); for (CtJavaDocTag ctJavaDocTag : ctJavaDoc.getTags()) { stringBuilder.append("\n").append(ctJavaDocTag.getType()).append(" ").append(ctJavaDocTag.getContent()); } String javadoc = stringBuilder.toString(); for (CtImport ctImport : this.usedImport.keySet()) { switch (ctImport.getImportKind()) { case TYPE: if (javadoc.contains(ctImport.getReference().getSimpleName()) && ctImport.getReference() instanceof CtTypeReference) { //assure that it is not just any occurrence of same substring, but it is real javadoc link to the same type if (matchesTypeName(javadoc, (CtTypeReference<?>) ctImport.getReference())) { this.setImportUsed(ctImport); } } break; } } }
@java.lang.Override public void visitCtImport(final spoon.reflect.declaration.CtImport ctImport) { spoon.reflect.declaration.CtImport other = ((spoon.reflect.declaration.CtImport) (this.stack.peek())); enter(ctImport); biScan(spoon.reflect.path.CtRole.IMPORT_REFERENCE, ctImport.getReference(), other.getReference()); biScan(spoon.reflect.path.CtRole.ANNOTATION, ctImport.getAnnotations(), other.getAnnotations()); biScan(spoon.reflect.path.CtRole.COMMENT, ctImport.getComments(), other.getComments()); exit(ctImport); }
case METHOD: if (isExecRef) { CtExecutableReference execRef = (CtExecutableReference) ctImport.getReference(); CtTypeReference declaringType = execRef.getDeclaringType(); CtFieldReference importFieldRef = (CtFieldReference) ctImport.getReference(); if (importFieldRef.getQualifiedName().equals(refQualifiedName)) { return this.setImportUsed(ctImport); if ((isExecRef || isFieldRef) && refDeclaringType != null) { String qualifiedName = refDeclaringType.getQualifiedName(); CtTypeMemberWildcardImportReferenceImpl importRef = (CtTypeMemberWildcardImportReferenceImpl) ctImport.getReference(); String importRefStr = importRef.getTypeReference().getQualifiedName(); if (qualifiedName.equals(importRefStr)) { CtTypeReference typeReference = (CtTypeReference) ctImport.getReference(); String typeImportQualifiedName = ctImport.getReference().getSimpleName();
@Override public void visitCtImport(final CtImport ctImport) { enter(ctImport); scan(CtRole.IMPORT_REFERENCE, ctImport.getReference()); scan(CtRole.ANNOTATION, ctImport.getAnnotations()); scan(CtRole.COMMENT, ctImport.getComments()); exit(ctImport); }
@java.lang.Override public void visitCtImport(final spoon.reflect.declaration.CtImport ctImport) { replaceElementIfExist(ctImport.getReference(), new spoon.support.visitor.replace.ReplacementVisitor.CtImportReferenceReplaceListener(ctImport)); replaceInListIfExist(ctImport.getAnnotations(), new spoon.support.visitor.replace.ReplacementVisitor.CtElementAnnotationsReplaceListener(ctImport)); replaceInListIfExist(ctImport.getComments(), new spoon.support.visitor.replace.ReplacementVisitor.CtElementCommentsReplaceListener(ctImport)); }
visitCtTypeReference((CtTypeReference) ctImport.getReference()); break; printer.writeKeyword("static"); printer.writeSpace(); visitCtExecutableReference((CtExecutableReference) ctImport.getReference()); break; printer.writeKeyword("static"); printer.writeSpace(); visitCtFieldReference((CtFieldReference) ctImport.getReference()); break; visitCtPackageReference((CtPackageReference) ctImport.getReference()); printer.writeSeparator("."); printer.writeIdentifier("*"); printer.writeKeyword("static"); printer.writeSpace(); visitCtTypeReference(((CtTypeMemberWildcardImportReference) ctImport.getReference()).getTypeReference()); printer.writeSeparator("."); printer.writeIdentifier("*");
switch (ctImport.getImportKind()) { case TYPE: CtTypeReference typeRef = (CtTypeReference) ctImport.getReference(); importTypeStr = typeRef.getQualifiedName(); if (!isJavaLangClasses(importTypeStr)) { CtPackageReference packageRef = (CtPackageReference) ctImport.getReference(); importTypeStr = packageRef.getQualifiedName() + ".*"; if (!isJavaLangClasses(importTypeStr)) { CtExecutableReference execRef = (CtExecutableReference) ctImport.getReference(); if (execRef.getDeclaringType() != null) { setStaticImports.add(this.removeInnerTypeSeparator(execRef.getDeclaringType().getQualifiedName()) + "." + execRef.getSimpleName()); CtFieldReference fieldRef = (CtFieldReference) ctImport.getReference(); setStaticImports.add(this.removeInnerTypeSeparator(fieldRef.getDeclaringType().getQualifiedName()) + "." + fieldRef.getSimpleName()); break; CtTypeMemberWildcardImportReference typeStarRef = (CtTypeMemberWildcardImportReference) ctImport.getReference(); importTypeStr = typeStarRef.getTypeReference().getQualifiedName(); if (!isJavaLangClasses(importTypeStr)) {
@java.lang.Override public void visitCtImport(final spoon.reflect.declaration.CtImport ctImport) { spoon.reflect.declaration.CtImport aCtImport = ctImport.getFactory().Core().createImport(); this.builder.copy(ctImport, aCtImport); aCtImport.setReference(this.cloneHelper.clone(ctImport.getReference())); aCtImport.setAnnotations(this.cloneHelper.clone(ctImport.getAnnotations())); aCtImport.setComments(this.cloneHelper.clone(ctImport.getComments())); this.cloneHelper.tailor(ctImport, aCtImport); this.other = aCtImport; }
private CtImport createImportWithPosition(CtReference ref, ImportReference importRef) { char[] content = sourceUnit.getContents(); CtImport imprt = factory.Type().createImport(ref); //include comment before import int declStart = importRef.declarationSourceStart; int commentStart = PositionBuilder.findNextNonWhitespace(false, content, declStart, PositionBuilder.findPrevNonWhitespace(content, 0, declStart - 1) + 1); imprt.setPosition(factory.Core().createCompoundSourcePosition(spoonUnit, importRef.sourceStart(), importRef.sourceEnd(), commentStart, importRef.declarationEnd, spoonUnit.getLineSeparatorPositions())); imprt.getReference().setPosition(factory.Core().createSourcePosition(spoonUnit, importRef.sourceStart(), importRef.sourceEnd(), spoonUnit.getLineSeparatorPositions())); return imprt; }
public void analyzeLib() { String sourcefile=this.faultyClass.getPosition().getFile().getAbsolutePath(); sourcefile = sourcefile.substring(0,sourcefile.lastIndexOf("/")); parseDirSingle(new File(sourcefile)); ImportScanner importContext = new ImportScannerImpl(); importContext.computeImports(this.faultyClass); Collection<CtImport> imports = importContext.getAllImports(); for (CtImport certainimport : imports) { String importedlibname=certainimport.getReference().toString(); if(importedlibname.indexOf(".")==-1) continue; if(certainimport.getImportKind()==CtImportKind.FIELD) { log.info("do not need to consider this case"); importedlibname=""; } else if(certainimport.getImportKind()==CtImportKind.TYPE) { importedlibname=importedlibname; } else if(certainimport.getImportKind()==CtImportKind.METHOD ||certainimport.getImportKind()==CtImportKind.ALL_TYPES) { importedlibname=importedlibname.substring(0,importedlibname.lastIndexOf(".")); } else if (certainimport.getImportKind()==CtImportKind.ALL_STATIC_MEMBERS) { log.info("temporily ignore this case"); importedlibname=""; } parseImportFile(importedlibname); } }