<s> package org . eclipse . jdt . internal . codeassist . impl ; import java . util . Map ; import org . eclipse . jdt . core . compiler . CharOperation ; import org . eclipse . jdt . internal . compiler . * ; import org . eclipse . jdt . internal . compiler . classfmt . ClassFileConstants ; import org . eclipse . jdt . internal . compiler . env . * ; import org . eclipse . jdt . internal . compiler . ast . * ; import org . eclipse . jdt . internal . compiler . lookup . * ; import org . eclipse . jdt . internal . compiler . parser . * ; import org . eclipse . jdt . internal . compiler . problem . ProblemSeverities ; import org . eclipse . jdt . internal . compiler . impl . * ; import org . eclipse . jdt . internal . core . NameLookup ; import org . eclipse . jdt . internal . core . SearchableEnvironment ; public abstract class Engine implements ITypeRequestor { public LookupEnvironment lookupEnvironment ; protected CompilationUnitScope unitScope ; public SearchableEnvironment nameEnvironment ; public AssistOptions options ; public CompilerOptions compilerOptions ; public boolean forbiddenReferenceIsError ; public boolean discouragedReferenceIsError ; public boolean importCachesInitialized = false ; public char [ ] [ ] [ ] importsCache ; public ImportBinding [ ] onDemandImportsCache ; public int importCacheCount = 0 ; public int onDemandImportCacheCount = 0 ; public char [ ] currentPackageName = null ; public Engine ( Map settings ) { this . options = new AssistOptions ( settings ) ; this . compilerOptions = new CompilerOptions ( settings ) ; this . forbiddenReferenceIsError = ( this . compilerOptions . getSeverity ( CompilerOptions . ForbiddenReference ) & ProblemSeverities . Error ) != 0 ; this . discouragedReferenceIsError = ( this . compilerOptions . getSeverity ( CompilerOptions . DiscouragedReference ) & ProblemSeverities . Error ) != 0 ; } public void accept ( IBinaryType binaryType , PackageBinding packageBinding , AccessRestriction accessRestriction ) { this . lookupEnvironment . createBinaryTypeFrom ( binaryType , packageBinding , accessRestriction ) ; } public void accept ( ICompilationUnit sourceUnit , AccessRestriction accessRestriction ) { CompilationResult result = new CompilationResult ( sourceUnit , 1 , 1 , this . compilerOptions . maxProblemsPerUnit ) ; AssistParser assistParser = getParser ( ) ; Object parserState = assistParser . becomeSimpleParser ( ) ; CompilationUnitDeclaration parsedUnit = assistParser . dietParse ( sourceUnit , result ) ; assistParser . restoreAssistParser ( parserState ) ; this . lookupEnvironment . buildTypeBindings ( parsedUnit , accessRestriction ) ; this . lookupEnvironment . completeTypeBindings ( parsedUnit , true ) ; } public void accept ( ISourceType [ ] sourceTypes , PackageBinding packageBinding , AccessRestriction accessRestriction ) { CompilationResult result = new CompilationResult ( sourceTypes [ 0 ] . getFileName ( ) , 1 , 1 , this . compilerOptions . maxProblemsPerUnit ) ; CompilationUnitDeclaration unit = SourceTypeConverter . buildCompilationUnit ( sourceTypes , SourceTypeConverter . FIELD_AND_METHOD | SourceTypeConverter . MEMBER_TYPE , this . lookupEnvironment . problemReporter , result ) ; if ( unit != null ) { this . lookupEnvironment . buildTypeBindings ( unit , accessRestriction ) ; this . lookupEnvironment . completeTypeBindings ( unit , true ) ; } } public abstract AssistParser getParser ( ) ; public void initializeImportCaches ( ) { if ( this . currentPackageName == null ) { initializePackageCache ( ) ; } ImportBinding [ ] importBindings = this . unitScope . imports ; int length = importBindings == null ? 0 : importBindings . length ; for ( int i = 0 ; i < length ; i ++ ) { ImportBinding importBinding = importBindings [ i ] ; if ( importBinding . onDemand ) { if ( this . onDemandImportsCache == null ) { this . onDemandImportsCache = new ImportBinding [ length - i ] ; } this . onDemandImportsCache [ this . onDemandImportCacheCount ++ ] = importBinding ; } else { if ( ! ( importBinding . resolvedImport instanceof MethodBinding ) || importBinding instanceof ImportConflictBinding ) { if ( this . importsCache == null ) { this . importsCache = new char [ length - i ] [ ] [ ] ; } this . importsCache [ this . importCacheCount ++ ] = new char [ ] [ ] { importBinding . compoundName [ importBinding . compoundName . length - 1 ] , CharOperation . concatWith ( importBinding . compoundName , '.' ) } ; } } } this . importCachesInitialized = true ; } public void initializePackageCache ( ) { if ( this . unitScope . fPackage != null ) { this . currentPackageName = CharOperation . concatWith ( this . unitScope . fPackage . compoundName , '.' ) ; } else if ( this . unitScope . referenceContext != null && this . unitScope . referenceContext . currentPackage != null ) { this . currentPackageName = CharOperation . concatWith ( this . unitScope . referenceContext . currentPackage . tokens , '.' ) ; } else { this . currentPackageName = CharOperation . NO_CHAR ; } } protected boolean mustQualifyType ( char [ ] packageName , char [ ] typeName , char [ ] enclosingTypeNames , int modifiers ) { if ( this . unitScope == null ) return true ; if ( ! this . importCachesInitialized ) { initializeImportCaches ( ) ; } for ( int i = 0 ; i < this . importCacheCount ; i ++ ) { char [ ] [ ] importName = this . importsCache [ i ] ; if ( CharOperation . equals ( typeName , importName [ 0 ] ) ) { char [ ] fullyQualifiedTypeName = enclosingTypeNames == null || enclosingTypeNames . length == 0 ? CharOperation . concat ( packageName , typeName , '.' ) : CharOperation . concat ( CharOperation . concat ( packageName , enclosingTypeNames , '.' ) , typeName , '.' ) ; return ! CharOperation . equals ( fullyQualifiedTypeName , importName [ 1 ] ) ; } } if ( ( enclosingTypeNames == null || enclosingTypeNames . length == 0 ) && CharOperation . equals ( this . currentPackageName , packageName ) ) return false ; char [ ] fullyQualifiedEnclosingTypeName = null ; for ( int i = 0 ; i < this . onDemandImportCacheCount ; i ++ ) { ImportBinding importBinding = this . onDemandImportsCache [ i ] ; Binding resolvedImport = importBinding . resolvedImport ; char [ ] [ ] importName = importBinding . compoundName ; char [ ] importFlatName = CharOperation . concatWith ( importName , '.' ) ; boolean isFound = false ; if ( resolvedImport instanceof ReferenceBinding ) { if ( enclosingTypeNames != null && enclosingTypeNames . length != 0 ) { if ( fullyQualifiedEnclosingTypeName == null ) { fullyQualifiedEnclosingTypeName = CharOperation . concat ( packageName , enclosingTypeNames , '.' ) ; } if ( CharOperation . equals ( fullyQualifiedEnclosingTypeName , importFlatName ) ) { if ( importBinding . isStatic ( ) ) { isFound = ( modifiers & ClassFileConstants . AccStatic ) != 0 ; } else { isFound = true ; } } } } else { if ( enclosingTypeNames == null || enclosingTypeNames . length == 0 ) { if ( CharOperation . equals ( packageName , importFlatName ) ) { if ( importBinding . isStatic ( ) ) { isFound = ( modifiers & ClassFileConstants . AccStatic ) != 0 ; } else { isFound = true ; } } } } if ( isFound ) { for ( int j = 0 ; j < this . onDemandImportCacheCount ; j ++ ) { if ( i != j ) { ImportBinding conflictingImportBinding = this . onDemandImportsCache [ j ] ; if ( conflictingImportBinding . resolvedImport instanceof ReferenceBinding ) { ReferenceBinding refBinding = ( ReferenceBinding ) conflictingImportBinding . resolvedImport ; if ( refBinding . getMemberType ( typeName ) != null ) { return true ; } } else { char [ ] conflictingImportName = CharOperation . concatWith ( conflictingImportBinding . compoundName , '.' ) ; if ( this . nameEnvironment . nameLookup . findType ( String . valueOf ( typeName ) , String . valueOf ( conflictingImportName ) , false , NameLookup . ACCEPT_ALL , false ) != null ) { return true ; } } } } return false ; } } return true ; } protected ASTNode parseBlockStatements ( CompilationUnitDeclaration unit , int position ) { int length = unit . types . length ; for ( int i = 0 ; i < length ; i ++ ) { TypeDeclaration type = unit . types [ i ] ; if ( type . declarationSourceStart < position && type . declarationSourceEnd >= position ) { getParser ( ) . scanner . setSource ( unit . compilationResult ) ; return parseBlockStatements ( type , unit , position ) ; } } return null ; } private ASTNode parseBlockStatements ( TypeDeclaration type , CompilationUnitDeclaration unit , int position ) { TypeDeclaration [ ] memberTypes = type . memberTypes ; if ( memberTypes != null ) { int length = memberTypes . length ; for ( int i = 0 ; i < length ; i ++ ) { TypeDeclaration memberType = memberTypes [ i ] ; if ( memberType . bodyStart > position ) continue ; if ( memberType . declarationSourceEnd >= position ) { return parseBlockStatements ( memberType , unit , position ) ; } } } AbstractMethodDeclaration [ ] methods = type . methods ; if ( methods != null ) { int length = methods . length ; for ( int i = 0 ; i < length ; i ++ ) { AbstractMethodDeclaration method = methods [ i ] ; if ( method . bodyStart > position + 1 ) continue ; if ( method . isDefaultConstructor ( ) ) continue ; if ( method . declarationSourceEnd >= position ) { getParser ( ) . parseBlockStatements ( method , unit ) ; return method ; } } } FieldDeclaration [ ] fields = type . fields ; if ( fields != null ) { int length = fields . length ; for ( int i = 0 ; i < length ; i ++ ) { FieldDeclaration field = fields [ i ] ; if ( field . sourceStart > position ) continue ; if ( field . declarationSourceEnd >= position ) { if ( field instanceof Initializer ) { getParser ( ) . parseBlockStatements ( ( Initializer ) field , type , unit ) ; } return field ; } } } return null ; } protected void reset ( boolean resetLookupEnvironment ) { if ( resetLookupEnvironment ) this . lookupEnvironment . reset ( ) ; } public static char [ ] getTypeSignature ( TypeBinding typeBinding ) { char [ ] result = typeBinding . signature ( ) ; if ( result != null ) { result = CharOperation . replaceOnCopy ( result , '/' , '.' ) ; } return result ; } public static char [ ] getSignature ( MethodBinding methodBinding ) { char [ ] result = null ; int oldMod = methodBinding . modifiers ; methodBinding . modifiers |= ExtraCompilerModifiers . AccGenericSignature ; result = methodBinding . genericSignature ( ) ; if ( result == null ) { result = methodBinding . signature ( ) ; } methodBinding . modifiers = oldMod ; if ( result != null ) { result = CharOperation . replaceOnCopy ( result , '/' , '.' ) ; } return result ; } public static char [ ] getSignature ( TypeBinding typeBinding ) { char [ ] result = null ; result = typeBinding . genericTypeSignature ( ) ; if ( result != null ) { result = CharOperation . replaceOnCopy ( result , '/' , '.' ) ; } return result ; } } </s>