* Copyright (c) 2000, 2007 IBM Corporation and others.

* All rights reserved. This program and the accompanying materials

* are made available under the terms of the Eclipse Public License v1.0

* which accompanies this distribution, and is available at

* http://www.eclipse.org/legal/epl-v10.html

*

* Contributors:

*     IBM Corporation - initial API and implementation

*******************************************************************************/

  long maxMemory = Runtime.getRuntime().maxMemory();   

  int ratio = (int) Math.round(((double) maxMemory) / (64 * 0x100000));

  switch (ratio) {

    case 0:

    case 1:

      MAX_AT_ONCE = 100;

      break;

    case 2:

      MAX_AT_ONCE = 200;

      break;

    case 3:

      MAX_AT_ONCE = 300;

      break;

    default:

      MAX_AT_ONCE = 400;

      break;

  }

}

* Time spent in the IJavaSearchResultCollector

*/

SimpleLookupTable bindings;

* An ast visitor that visits local type declarations.

*/

  IJavaElement enclosingElement;

  Binding enclosingElementBinding;

  MatchingNodeSet nodeSet;

  HashtableOfIntValues occurrencesCounts = new HashtableOfIntValues(); // key = class name (char[]), value = occurrenceCount (int)

  public LocalDeclarationVisitor(IJavaElement enclosingElement, Binding enclosingElementBinding, MatchingNodeSet nodeSet) {

    this.enclosingElement = enclosingElement;

    this.enclosingElementBinding = enclosingElementBinding;

    this.nodeSet = nodeSet;

  }

  public boolean visit(TypeDeclaration typeDeclaration, BlockScope unused) {

    try {

      char[] simpleName;

      if ((typeDeclaration.bits & ASTNode.IsAnonymousType) != 0) {       

        simpleName = CharOperation.NO_CHAR;

      } else {

        simpleName = typeDeclaration.name;

      }

      int occurrenceCount = occurrencesCounts.get(simpleName);

      if (occurrenceCount == HashtableOfIntValues.NO_VALUE) {

        occurrenceCount = 1;

      } else {

        occurrenceCount = occurrenceCount + 1;

      }

      occurrencesCounts.put(simpleName, occurrenceCount);

      if ((typeDeclaration.bits & ASTNode.IsAnonymousType) != 0) {       

        reportMatching(typeDeclaration, this.enclosingElement, -1, nodeSet, occurrenceCount);

      } else {

        Integer level = (Integer) nodeSet.matchingNodes.removeKey(typeDeclaration);

        reportMatching(typeDeclaration, this.enclosingElement, level != null ? level.intValue() : -1, nodeSet, occurrenceCount);

      }

      return false; // don't visit members as this was done during reportMatching(...)

    } catch (CoreException e) {

      throw new WrappedCoreException(e);

    }

  }

}

  public org.aspectj.org.eclipse.jdt.core.ICompilationUnit workingCopy;

  WorkingCopyDocument(org.aspectj.org.eclipse.jdt.core.ICompilationUnit workingCopy, SearchParticipant participant) {

    super(workingCopy.getPath().toString(), participant);

    this.charContents = ((CompilationUnit)workingCopy).getContents();

    this.workingCopy = workingCopy;

  }

  public String toString() {

    return "WorkingCopyDocument for " + getPath(); //$NON-NLS-1$

  }

}

 

  private static final long serialVersionUID = 8354329870126121212L; // backward compatible

  public CoreException coreException;

  public WrappedCoreException(CoreException coreException) {

    this.coreException = coreException;

  }

}

  // working copies take precedence over corresponding compilation units

  HashMap workingCopyDocuments = workingCopiesThatCanSeeFocus(copies, pattern.focus, pattern.isPolymorphicSearch(), participant);

  SearchDocument[] matches = null;

  int length = indexMatches.length;

  for (int i = 0; i < length; i++) {

    SearchDocument searchDocument = indexMatches[i];

    if (searchDocument.getParticipant() == participant) {

      SearchDocument workingCopyDocument = (SearchDocument) workingCopyDocuments.remove(searchDocument.getPath());

      if (workingCopyDocument != null) {

        if (matches == null) {

          System.arraycopy(indexMatches, 0, matches = new SearchDocument[length], 0, length);

        }

        matches[i] = workingCopyDocument;

      }

    }

  }

  if (matches == null) { // no working copy

    matches = indexMatches;

  }

  int remainingWorkingCopiesSize = workingCopyDocuments.size();

  if (remainingWorkingCopiesSize != 0) {

    System.arraycopy(matches, 0, matches = new SearchDocument[length+remainingWorkingCopiesSize], 0, length);

    Iterator iterator = workingCopyDocuments.values().iterator();

    int index = length;

    while (iterator.hasNext()) {

      matches[index++] = (SearchDocument) iterator.next();

    }

  }

  return matches;

  pattern.focus = focus;

* Returns the working copies that can see the given focus.

*/

  if (copies == null) return new HashMap();

  if (focus != null) {

    while (!(focus instanceof IJavaProject) && !(focus instanceof JarPackageFragmentRoot)) {

      focus = focus.getParent();

    }

  }

  HashMap result = new HashMap();

  for (int i=0, length = copies.length; i<length; i++) {

    org.aspectj.org.eclipse.jdt.core.ICompilationUnit workingCopy = copies[i];

    IPath projectOrJar = MatchLocator.getProjectOrJar(workingCopy).getPath();

    if (focus == null || IndexSelector.canSeeFocus(focus, isPolymorphicSearch, projectOrJar)) {

      result.put(

        workingCopy.getPath().toString(),

        new WorkingCopyDocument(workingCopy, participant)

      );

    }

  }

  return result;

  IClassFile classFile = type.getClassFile();

  JavaModelManager manager = JavaModelManager.getJavaModelManager();

  if (classFile.isOpen())

    return (ClassFileReader) manager.getInfo(type);

  PackageFragment pkg = (PackageFragment) type.getPackageFragment();

  IPackageFragmentRoot root = (IPackageFragmentRoot) pkg.getParent();

  try {

    if (!root.isArchive())

      return Util.newClassFileReader(type.getResource());

    ZipFile zipFile = null;

    try {

      IPath zipPath = root.getPath();

      if (JavaModelManager.ZIP_ACCESS_VERBOSE)

        System.out.println("(" + Thread.currentThread() + ") [MatchLocator.classFileReader()] Creating ZipFile on " + zipPath); //$NON-NLS-1$  //$NON-NLS-2$

      zipFile = manager.getZipFile(zipPath);

      String classFileName = classFile.getElementName();

      String path = Util.concatWith(pkg.names, classFileName, '/');

      return ClassFileReader.read(zipFile, path);

    } finally {

      manager.closeZipFile(zipFile);

    }

  } catch (ClassFormatException e) {

    // invalid class file: return null

  } catch (CoreException e) {

    // cannot read class file: return null

  } catch (IOException e) {

    // cannot read class file: return null

  }

  return null;

  return new AndPattern(0/*no kind*/, 0/*no rule*/) {

    SearchPattern current = leftPattern;

    public SearchPattern currentPattern() {

      return this.current;

    }

    protected boolean hasNextQuery() {

      if (this.current == leftPattern) {

        this.current = rightPattern;

        return true;

      }

      return false;

    }

    protected void resetQuery() {

      this.current = leftPattern;

    }

  };

* Query a given index for matching entries. Assumes the sender has opened the index and will close when finished.

*/

  pattern.findIndexMatches(index, requestor, participant, scope, monitor);

  while (!(element instanceof IJavaProject) && !(element instanceof JarPackageFragmentRoot)) {

    element = element.getParent();

  }

  return element;

  return pattern == null || pattern.focus == null ? null : getProjectOrJar(pattern.focus);

  SearchPattern pattern,

  SearchRequestor requestor,

  IJavaSearchScope scope,

  IProgressMonitor progressMonitor) {

   

  this.pattern = pattern;

  this.patternLocator = PatternLocator.patternLocator(this.pattern);

  this.matchContainer = this.patternLocator.matchContainer();

  this.requestor = requestor;

  this.scope = scope;

  this.progressMonitor = progressMonitor;

* Add an additional binary type

*/

  this.lookupEnvironment.createBinaryTypeFrom(binaryType, packageBinding, accessRestriction);

* Add an additional compilation unit into the loop

*  ->  build compilation unit declarations, their bindings and record their results.

*/

  // Switch the current policy and compilation result for this unit to the requested one.

  CompilationResult unitResult = new CompilationResult(sourceUnit, 1, 1, this.options.maxProblemsPerUnit);

  try {

    CompilationUnitDeclaration parsedUnit = basicParser().dietParse(sourceUnit, unitResult);

    this.lookupEnvironment.buildTypeBindings(parsedUnit, accessRestriction);

    this.lookupEnvironment.completeTypeBindings(parsedUnit, true);

  } catch (AbortCompilationUnit e) {

    // at this point, currentCompilationUnitResult may not be sourceUnit, but some other

    // one requested further along to resolve sourceUnit.

    if (unitResult.compilationUnit == sourceUnit) { // only report once

      //requestor.acceptResult(unitResult.tagAsAccepted());

    } else {

      throw e; // want to abort enclosing request to compile

    }

  }

  // Display unit error in debug mode

  if (BasicSearchEngine.VERBOSE) {

    if (unitResult.problemCount > 0) {

      System.out.println(unitResult);

    }

  }

}

* Add additional source types

*/

  // case of SearchableEnvironment of an IJavaProject is used

  ISourceType sourceType = sourceTypes[0];

  while (sourceType.getEnclosingType() != null)

    sourceType = sourceType.getEnclosingType();

  if (sourceType instanceof SourceTypeElementInfo) {

    // get source

    SourceTypeElementInfo elementInfo = (SourceTypeElementInfo) sourceType;

    IType type = elementInfo.getHandle();

    ICompilationUnit sourceUnit = (ICompilationUnit) type.getCompilationUnit();

    accept(sourceUnit, accessRestriction);

  } else {

    CompilationResult result = new CompilationResult(sourceType.getFileName(), 1, 1, 0);

    CompilationUnitDeclaration unit =

      SourceTypeConverter.buildCompilationUnit(

        sourceTypes,

        SourceTypeConverter.FIELD_AND_METHOD // need field and methods

        | SourceTypeConverter.MEMBER_TYPE, // need member types

        // no need for field initialization

        this.lookupEnvironment.problemReporter,

        result);

    this.lookupEnvironment.buildTypeBindings(unit, accessRestriction);

    this.lookupEnvironment.completeTypeBindings(unit, true);

  }

} 

  if (this.basicParser == null) {

    ProblemReporter problemReporter =

      new ProblemReporter(

        DefaultErrorHandlingPolicies.proceedWithAllProblems(),

        this.options,

        new DefaultProblemFactory());

    this.basicParser = new Parser(problemReporter, false);

    this.basicParser.reportOnlyOneSyntaxError = true;

  }

  return this.basicParser;

* Caches the given binary type in the lookup environment and returns it.

* Returns the existing one if already cached.

* Returns null if source type binding was cached.

*/

  IType enclosingType = type.getDeclaringType();

  if (enclosingType != null)

    cacheBinaryType(enclosingType, null); // cache enclosing types first, so that binary type can be found in lookup enviroment

  if (binaryType == null) {

    ClassFile classFile = (ClassFile) type.getClassFile();

    try {

      binaryType = getBinaryInfo(classFile, classFile.getResource());

    } catch (CoreException e) {

      if (e instanceof JavaModelException) {

        throw (JavaModelException) e;

      } else {

        throw new JavaModelException(e);

      }

    }

  }

  BinaryTypeBinding binding = this.lookupEnvironment.cacheBinaryType(binaryType, null /*no access restriction*/);

  if (binding == null) { // it was already cached as a result of a previous query

    char[][] compoundName = CharOperation.splitOn('.', type.getFullyQualifiedName().toCharArray());

    ReferenceBinding referenceBinding = this.lookupEnvironment.getCachedType(compoundName);

    if (referenceBinding != null && (referenceBinding instanceof BinaryTypeBinding))

      binding = (BinaryTypeBinding) referenceBinding; // if the binding could be found and if it comes from a binary type

  }

  return binding;

* Computes the super type names of the focus type if any.

*/

  String fullyQualifiedName = focusType.getFullyQualifiedName();

  int lastDot = fullyQualifiedName.lastIndexOf('.');

  char[] qualification = lastDot == -1 ? CharOperation.NO_CHAR : fullyQualifiedName.substring(0, lastDot).toCharArray();

  char[] simpleName = focusType.getElementName().toCharArray();

  SuperTypeNamesCollector superTypeNamesCollector =

    new SuperTypeNamesCollector(

      this.pattern,

      simpleName,

      qualification,

      new MatchLocator(this.pattern, this.requestor, this.scope, this.progressMonitor), // clone MatchLocator so that it has no side effect

      focusType,

      this.progressMonitor);

  try {

    this.allSuperTypeNames = superTypeNamesCollector.collect();

  } catch (JavaModelException e) {

    // problem collecting super type names: leave it null

  }

  return this.allSuperTypeNames;

* Creates an IMethod from the given method declaration and type.

*/

  if (!(parent instanceof IType)) return parent;

  IType type = (IType) parent;

  Argument[] arguments = method.arguments;

  int argCount = arguments == null ? 0 : arguments.length;

  if (type.isBinary()) {

    // don't cache the methods of the binary type

    // fall thru if its a constructor with a synthetic argument... find it the slower way

    ClassFileReader reader = classFileReader(type);

    if (reader != null) {

      IBinaryMethod[] methods = reader.getMethods();

      if (methods != null) {

        // build arguments names

        boolean firstIsSynthetic = false;

        if (reader.isMember() && method.isConstructor() && !Flags.isStatic(reader.getModifiers())) { // see https://bugs.eclipse.org/bugs/show_bug.cgi?id=48261

          firstIsSynthetic = true;

          argCount++;

        }

        char[][] argumentTypeNames = new char[argCount][];

        for (int i = 0; i < argCount; i++) {

          char[] typeName = null;

          if (i == 0 && firstIsSynthetic) {

            typeName = type.getDeclaringType().getFullyQualifiedName().toCharArray();

          } else if (arguments != null) {

            TypeReference typeRef = arguments[firstIsSynthetic ? i - 1 : i].type;

            typeName = CharOperation.concatWith(typeRef.getTypeName(), '.');

            for (int k = 0, dim = typeRef.dimensions(); k < dim; k++)

              typeName = CharOperation.concat(typeName, new char[] {'[', ']'});

          }

          if (typeName == null) {

            // invalid type name

            return null;

          }

          argumentTypeNames[i] = typeName;

        }

       

        // return binary method

        return createBinaryMethodHandle(type, method.selector, argumentTypeNames);

      }

    }

    return null;

  }

  String[] parameterTypeSignatures = new String[argCount];

  if (arguments != null) {

    for (int i = 0; i < argCount; i++) {

      TypeReference typeRef = arguments[i].type;

      char[] typeName = CharOperation.concatWith(typeRef.getParameterizedTypeName(), '.');

      parameterTypeSignatures[i] = Signature.createTypeSignature(typeName, false);

    }

  }

  return createMethodHandle(type, new String(method.selector), parameterTypeSignatures);

* Create binary method handle

*/

  ClassFileReader reader = MatchLocator.classFileReader(type);

  if (reader != null) {

    IBinaryMethod[] methods = reader.getMethods();

    if (methods != null) {

      int argCount = argumentTypeNames == null ? 0 : argumentTypeNames.length;

      nextMethod : for (int i = 0, methodsLength = methods.length; i < methodsLength; i++) {

        IBinaryMethod binaryMethod = methods[i];

        char[] selector = binaryMethod.isConstructor() ? type.getElementName().toCharArray() : binaryMethod.getSelector();

        if (CharOperation.equals(selector, methodSelector)) {

          char[] signature = binaryMethod.getGenericSignature();

          if (signature == null) signature = binaryMethod.getMethodDescriptor();

          char[][] parameterTypes = Signature.getParameterTypes(signature);

          if (argCount != parameterTypes.length) continue nextMethod;

          if (argumentTypeNames != null) {

            for (int j = 0; j < argCount; j++) {

              char[] parameterTypeName = ClassFileMatchLocator.convertClassFileFormat(parameterTypes[j]);

              if (!CharOperation.endsWith(Signature.toCharArray(Signature.getTypeErasure(parameterTypeName)), CharOperation.replaceOnCopy(argumentTypeNames[j], '$', '.')))

                continue nextMethod;

              parameterTypes[j] = parameterTypeName;

            }

          }

          return (IMethod) createMethodHandle(type, new String(selector), CharOperation.toStrings(parameterTypes));

        }

      }

    }

  }

  return null;

* Create method handle.

* Store occurences for create handle to retrieve possible duplicate ones.

*/

  IMethod methodHandle = type.getMethod(methodName, parameterTypeSignatures);

  if (methodHandle instanceof SourceMethod) {

    while (this.methodHandles.contains(methodHandle)) {

      ((SourceMethod) methodHandle).occurrenceCount++;

    }

  }

  this.methodHandles.add(methodHandle);

  return methodHandle;

* Creates an IField from the given field declaration and type.

*/

  if (!(parent instanceof IType)) return parent;

  IType type = (IType) parent;

  switch (fieldDeclaration.getKind()) {

    case AbstractVariableDeclaration.FIELD :

    case AbstractVariableDeclaration.ENUM_CONSTANT :

      return ((IType) parent).getField(new String(fieldDeclaration.name));

  }

  if (type.isBinary()) {

    // do not return initializer for binary types

    // see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=98378

    return type;

  }

  // find occurence count of the given initializer in its type declaration

  int occurrenceCount = 0;

  FieldDeclaration[] fields = typeDeclaration.fields;

  for (int i = 0, length = fields.length; i < length; i++) {

    if (fields[i].getKind() == AbstractVariableDeclaration.INITIALIZER) {

      occurrenceCount++;

      if (fields[i].equals(fieldDeclaration)) break;

    }

  }

  return ((IType) parent).getInitializer(occurrenceCount);

* Create an handle for a local variable declartion (may be a local variable or type parameter).

*/

  switch (variableDeclaration.getKind()) {

    case AbstractVariableDeclaration.LOCAL_VARIABLE:

      return new LocalVariable((JavaElement)parent,

        new String(variableDeclaration.name),

        variableDeclaration.declarationSourceStart,

        variableDeclaration.declarationSourceEnd,

        variableDeclaration.sourceStart,

        variableDeclaration.sourceEnd,

        new String(variableDeclaration.type.resolvedType.signature())

      );

    case AbstractVariableDeclaration.PARAMETER:

      return new LocalVariable((JavaElement)parent,

        new String(variableDeclaration.name),

        variableDeclaration.declarationSourceStart,

        variableDeclaration.declarationSourceEnd,

        variableDeclaration.sourceStart,

        variableDeclaration.sourceEnd,

        new String(variableDeclaration.type.resolvedType.signature())

      );

    case AbstractVariableDeclaration.TYPE_PARAMETER:

      return new org.aspectj.org.eclipse.jdt.internal.core.TypeParameter((JavaElement)parent, new String(variableDeclaration.name));

  }

  return null;

* Creates hierarchy resolver if needed.

* Returns whether focus is visible.

*/

  // cache focus type if not a possible match

  char[][] compoundName = CharOperation.splitOn('.', focusType.getFullyQualifiedName().toCharArray());

  boolean isPossibleMatch = false;

  for (int i = 0, length = possibleMatches.length; i < length; i++) {

    if (CharOperation.equals(possibleMatches[i].compoundName, compoundName)) {

      isPossibleMatch = true;

      break;

    }

  }

  if (!isPossibleMatch) {

    if (focusType.isBinary()) {

      try {

        cacheBinaryType(focusType, null);

      } catch (JavaModelException e) {

        return false;

      }

    } else {

      // cache all types in the focus' compilation unit (even secondary types)

      accept((ICompilationUnit) focusType.getCompilationUnit(), null /*TODO no access restriction*/);

    }

  }

  // resolve focus type

  this.hierarchyResolver = new HierarchyResolver(this.lookupEnvironment, null/*hierarchy is not going to be computed*/);

  ReferenceBinding binding = this.hierarchyResolver.setFocusType(compoundName);

  return binding != null && binding.isValidBinding() && (binding.tagBits & TagBits.HierarchyHasProblems) == 0;

* Creates an IImportDeclaration from the given import statement

*/

  char[] importName = CharOperation.concatWith(importRef.getImportName(), '.');

  if ((importRef.bits & ASTNode.OnDemand) != 0)

    importName = CharOperation.concat(importName, ".*" .toCharArray()); //$NON-NLS-1$

  Openable openable = this.currentPossibleMatch.openable;

  if (openable instanceof CompilationUnit)

    return ((CompilationUnit) openable).getImport(new String(importName));