import com.intellij.psi.scope.PsiScopeProcessor; //导入依赖的package包/类
public static boolean processChildDeclarations(PsiElement element,
    PsiScopeProcessor processor, ResolveState substitutor,
    PsiElement lastParent, PsiElement place) {
    PsiElement run = (lastParent == null) ? element.getLastChild()
                                          : lastParent.getPrevSibling();

    while (run != null) {
        if (!run.processDeclarations(processor, substitutor, null, place)) {
            return false;
        }

        run = run.getPrevSibling();
    }

    return true;
}
 

import com.intellij.psi.scope.PsiScopeProcessor; //导入依赖的package包/类
public boolean processDeclarations(@NotNull
PsiScopeProcessor processor, @NotNull
ResolveState resolveState, PsiElement lastParent, @NotNull
PsiElement place) {
    if ((lastParent != null) && (lastParent.getParent() == this)) {
        final LuaParameter[] params = getParameters().getLuaParameters();

        for (LuaParameter param : params) {
            if (!processor.execute(param, resolveState)) {
                return false;
            }
        }
    }

    return true;
}
 

import com.intellij.psi.scope.PsiScopeProcessor; //导入依赖的package包/类
public boolean processDeclarations(@NotNull PsiScopeProcessor processor,
                                   @NotNull ResolveState resolveState,
                                   PsiElement lastParent,
                                   @NotNull PsiElement place) {

    PsiElement parent = place.getParent();
    while(parent != null && !(parent instanceof LuaPsiFile)) {
        if (parent == getBlock() ) {
            LuaExpression[] names = getIndices();
            for (LuaExpression name : names) {
                 if (!processor.execute(name, resolveState)) return false;
            }
        }

        parent = parent.getParent();
    }
   return true;
}
 

import com.intellij.psi.scope.PsiScopeProcessor; //导入依赖的package包/类
public boolean processDeclarations(@NotNull PsiScopeProcessor processor,
                                   @NotNull ResolveState resolveState,
                                   PsiElement lastParent,
                                   @NotNull PsiElement place) {

    PsiElement parent = place.getParent();
    while (parent != null && !(parent instanceof LuaPsiFile)) {
        if (parent == getBlock()) {
            if (!processor.execute(getIndex(), resolveState)) return false;
        }

        parent = parent.getParent();
    }

    return true;
}
 

import com.intellij.psi.scope.PsiScopeProcessor; //导入依赖的package包/类
@Override
public void process(@NotNull List<String> methodCallInfo,
                    @NotNull PsiScopeProcessor processor,
                    @NotNull ResolveState state,
                    @NotNull PsiElement place) {
  if (methodCallInfo.isEmpty() || methodCallInfo.size() < 3 ||
      !"repositories".equals(methodCallInfo.get(2)) || !"maven".equals(methodCallInfo.get(1))) {
    return;
  }
  GroovyPsiManager psiManager = GroovyPsiManager.getInstance(place.getProject());
  GradleResolverUtil.processDeclarations(
    psiManager, processor, state, place,
    GradleCommonClassNames.GRADLE_API_ARTIFACTS_REPOSITORIES_MAVEN_ARTIFACT_REPOSITORY);
  PsiClass contributorClass = psiManager.findClassWithCache(
    GradleCommonClassNames.GRADLE_API_ARTIFACTS_REPOSITORIES_MAVEN_ARTIFACT_REPOSITORY, place.getResolveScope());
  if (contributorClass == null) return;
  GradleResolverUtil.processMethod(methodCallInfo.get(0), contributorClass, processor, state, place);
}
 

import com.intellij.psi.scope.PsiScopeProcessor; //导入依赖的package包/类
@Override
public boolean processDeclarations(@NotNull PsiScopeProcessor processor,
                                   @NotNull ResolveState state,
                                   @Nullable PsiElement lastParent,
                                   @NotNull PsiElement place) {
  if (isAncestor(place)) {
    return true;
  }
  if (isStatic() && lastParent instanceof GrImportStatement) return true;

  if (isOnDemand()) {
    if (!processDeclarationsForMultipleElements(processor, lastParent, place, state)) return false;
  }
  else {
    if (!processDeclarationsForSingleElement(processor, lastParent, place, state)) return false;
  }

  return true;
}
 

import com.intellij.psi.scope.PsiScopeProcessor; //导入依赖的package包/类
public static boolean categoryIteration(GrClosableBlock place, final PsiScopeProcessor processor, ResolveState state) {
  final ClassHint classHint = processor.getHint(ClassHint.KEY);
  if (classHint != null && !classHint.shouldProcess(ClassHint.ResolveKind.METHOD)) return true;
  
  final GrMethodCall call = checkMethodCall(place, USE);
  if (call == null) return true;

  final GrClosableBlock[] closures = call.getClosureArguments();
  GrExpression[] args = call.getExpressionArguments();
  if (!(placeEqualsSingleClosureArg(place, closures) || placeEqualsLastArg(place, args))) return true;

  if (!(call.resolveMethod() instanceof GrGdkMethod)) return true;

  state = state.put(ClassHint.RESOLVE_CONTEXT, call);

  if ((args.length == 1 || args.length == 2 && placeEqualsLastArg(place, args))) {
    PsiType type = args[0].getType();
    if (type instanceof GrTupleType) {
      return processTypesFromTuple((GrTupleType)type, processor, state, place);
    }
  }
  return processTypesFomArgs(args, processor, state, place);
}
 

import com.intellij.psi.scope.PsiScopeProcessor; //导入依赖的package包/类
public static boolean walkChildrenScopes(@NotNull PsiElement thisElement,
                                         @NotNull PsiScopeProcessor processor,
                                         @NotNull ResolveState state,
                                         PsiElement lastParent,
                                         PsiElement place) {
  PsiElement child = null;
  if (lastParent != null && lastParent.getParent() == thisElement) {
    child = lastParent.getPrevSibling();
    if (child == null) return true; // first element
  }

  if (child == null) {
    child = thisElement.getLastChild();
  }

  while (child != null) {
    if (!child.processDeclarations(processor, state, null, place)) return false;
    child = child.getPrevSibling();
  }

  return true;
}
 

import com.intellij.psi.scope.PsiScopeProcessor; //导入依赖的package包/类
@NotNull
public static List<PyImportElement> getVisibleImports(@NotNull ScopeOwner owner) {
  final List<PyImportElement> visibleImports = new ArrayList<PyImportElement>();
  PyResolveUtil.scopeCrawlUp(new PsiScopeProcessor() {
    @Override
    public boolean execute(@NotNull PsiElement element, @NotNull ResolveState state) {
      if (element instanceof PyImportElement) {
        visibleImports.add((PyImportElement)element);
      }
      return true;
    }

    @Nullable
    @Override
    public <T> T getHint(@NotNull Key<T> hintKey) {
      return null;
    }

    @Override
    public void handleEvent(@NotNull Event event, @Nullable Object associated) {
    }
  }, owner, null, null);
  return visibleImports;
}
 

import com.intellij.psi.scope.PsiScopeProcessor; //导入依赖的package包/类
@Override
public boolean processClassLevelDeclarations(@NotNull PsiScopeProcessor processor) {
  final PyClassStub stub = getStub();
  if (stub != null) {
    final List<StubElement> children = stub.getChildrenStubs();
    for (StubElement child : children) {
      if (!processor.execute(child.getPsi(), ResolveState.initial())) {
        return false;
      }
    }
  }
  else {
    PyResolveUtil.scopeCrawlUp(processor, this, null, this);
  }
  return true;
}
 

import com.intellij.psi.scope.PsiScopeProcessor; //导入依赖的package包/类
@Override
public boolean processDeclarations(@NotNull PsiScopeProcessor processor, @NotNull ResolveState state, PsiElement lastParent, @NotNull PsiElement place) {
  processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, this);
  PsiElement[] decls = getDeclaredElements();
  for (PsiElement decl : decls) {
    if (decl != lastParent) {
      if (!processor.execute(decl, state)) return false;
    }
    else {
      final ElementClassHint hint = processor.getHint(ElementClassHint.KEY);
      if (lastParent instanceof PsiClass) {
        if (hint == null || hint.shouldProcess(ElementClassHint.DeclarationKind.CLASS)) {
          if (!processor.execute(lastParent, state)) return false;
        }
      }
    }
  }

  return true;
}
 

import com.intellij.psi.scope.PsiScopeProcessor; //导入依赖的package包/类
public static boolean processStaticImports(@NotNull PsiScopeProcessor resolver,
                                           @NotNull PsiFile file,
                                           @NotNull ResolveState state,
                                           @NotNull PsiElement place) {
  if (!shouldProcessMethods(resolver.getHint(ClassHint.KEY))) return true;

  return file.processDeclarations(new GrDelegatingScopeProcessorWithHints(resolver, null, ClassHint.RESOLVE_KINDS_METHOD) {
    @Override
    public boolean execute(@NotNull PsiElement element, @NotNull ResolveState _state) {
      if (_state.get(RESOLVE_CONTEXT) instanceof GrImportStatement) {
        super.execute(element, _state);
      }
      return true;
    }
  }, state, null, place);
}
 

import com.intellij.psi.scope.PsiScopeProcessor; //导入依赖的package包/类
@Override
public boolean processDeclarations(@NotNull PsiScopeProcessor processor,
                                   @NotNull ResolveState state,
                                   @Nullable PsiElement lastParent,
                                   @NotNull PsiElement place) {
  if (!ResolveUtil.shouldProcessProperties(processor.getHint(ClassHint.KEY))) return true;

  if (lastParent != null && !(getParent() instanceof GrTypeDefinitionBody) && lastParent == getTupleInitializer()) {
    return true;
  }

  for (final GrVariable variable : getVariables()) {
    if (lastParent == variable) break;
    if (lastParent instanceof GrMethod && !(variable instanceof GrField)) break;
    if (!ResolveUtil.processElement(processor, variable, state)) return false;
  }

  return true;
}
 

import com.intellij.psi.scope.PsiScopeProcessor; //导入依赖的package包/类
private static void resolveToMethodWithClosure(PsiElement place,
                                               PsiElement resolveToElement,
                                               String closureTypeFqcn,
                                               PsiScopeProcessor processor,
                                               ResolveState state,
                                               GroovyPsiManager psiManager) {
  if (place.getParent() instanceof GrMethodCallExpression) {
    GrLightMethodBuilder methodWithClosure =
      GradleResolverUtil.createMethodWithClosure(place.getText(), closureTypeFqcn, null, place, psiManager);
    if (methodWithClosure != null) {
      processor.execute(methodWithClosure, state);
      methodWithClosure.setNavigationElement(resolveToElement);
    }
  } else if (place.getParent() instanceof GrReferenceExpression) {
    GrLightVariable variable = new GrLightVariable(place.getManager(), place.getText(), closureTypeFqcn, place);
    processor.execute(variable, state);
  }
}
 

import com.intellij.psi.scope.PsiScopeProcessor; //导入依赖的package包/类
@Override
public boolean processDeclarations(@NotNull final PsiScopeProcessor processor,
                                   @NotNull final ResolveState state,
                                   PsiElement lastParent,
                                   @NotNull PsiElement place) {
  assert isValid();

  if (processor instanceof ClassResolverProcessor &&
      isPhysical() &&
      (getUserData(PsiFileEx.BATCH_REFERENCE_PROCESSING) == Boolean.TRUE || myResolveCache.hasUpToDateValue())) {
    final ClassResolverProcessor hint = (ClassResolverProcessor)processor;
    String name = hint.getName(state);
    MostlySingularMultiMap<String, SymbolCollectingProcessor.ResultWithContext> cache = myResolveCache.getValue();
    MyResolveCacheProcessor cacheProcessor = new MyResolveCacheProcessor(processor, state);
    return name != null ? cache.processForKey(name, cacheProcessor) : cache.processAllValues(cacheProcessor);
  }

  return processDeclarationsNoGuess(processor, state, lastParent, place);
}
 

import com.intellij.psi.scope.PsiScopeProcessor; //导入依赖的package包/类
@Override
public boolean processDeclarations(@NotNull PsiScopeProcessor processor,
                                   @NotNull ResolveState state,
                                   PsiElement lastParent,
                                   @NotNull PsiElement place) {
  if (lastParent instanceof PsiExpressionList) return true;

  final PsiClassStub stub = getStub();
  if (stub != null) {
    // no tree is loaded
    // that means we could not have come from resolving something inside anonymous class, we just resolving the base class reference
    // so skip the (very expensive) getBaseClassReference() call which would load tree
    return true;
  }

  if (lastParent != null/* IMPORTANT: do not call getBaseClassReference() for lastParent == null and lastParent which is not under our node - loads tree!*/
      && lastParent.getParent() == this && lastParent == getBaseClassReference()) {
    return true;
  }
  return super.processDeclarations(processor, state, lastParent, place);
}
 

import com.intellij.psi.scope.PsiScopeProcessor; //导入依赖的package包/类
public static boolean doTreeWalkUp(@NotNull final PsiElement place,
                                   @NotNull final PsiElement originalPlace,
                                   @NotNull final PsiScopeProcessor processor,
                                   @Nullable final PsiScopeProcessor nonCodeProcessor,
                                   @NotNull final ResolveState state) {
  final GrClosableBlock maxScope = nonCodeProcessor != null ? PsiTreeUtil.getParentOfType(place, GrClosableBlock.class, true, PsiFile.class) : null;

  return PsiTreeUtil.treeWalkUp(place, maxScope, new PairProcessor<PsiElement, PsiElement>() {
    @Override
    public boolean process(PsiElement scope, PsiElement lastParent) {
      ProgressManager.checkCanceled();
      if (!doProcessDeclarations(originalPlace, lastParent, scope, substituteProcessor(processor, scope), nonCodeProcessor, state)) {
        return false;
      }
      issueLevelChangeEvents(processor, scope);
      return true;
    }
  });
}
 

import com.intellij.psi.scope.PsiScopeProcessor; //导入依赖的package包/类
@Override
public boolean processInstanceLevelDeclarations(@NotNull PsiScopeProcessor processor, @Nullable PsiElement location) {
  Map<String, PyTargetExpression> declarationsInMethod = new HashMap<String, PyTargetExpression>();
  PyFunction instanceMethod = PsiTreeUtil.getParentOfType(location, PyFunction.class);
  final PyClass containingClass = instanceMethod != null ? instanceMethod.getContainingClass() : null;
  if (instanceMethod != null && containingClass != null && CompletionUtil.getOriginalElement(containingClass) == this) {
    collectInstanceAttributes(instanceMethod, declarationsInMethod);
    for (PyTargetExpression targetExpression : declarationsInMethod.values()) {
      if (!processor.execute(targetExpression, ResolveState.initial())) {
        return false;
      }
    }
  }
  for (PyTargetExpression expr : getInstanceAttributes()) {
    if (declarationsInMethod.containsKey(expr.getName())) {
      continue;
    }
    if (!processor.execute(expr, ResolveState.initial())) return false;
  }
  return true;
}
 

import com.intellij.psi.scope.PsiScopeProcessor; //导入依赖的package包/类
@Override
public void processDynamicElements(@NotNull PsiType qualifierType,
                                   @Nullable PsiClass aClass,
                                   @NotNull PsiScopeProcessor processor,
                                   @NotNull PsiElement place,
                                   @NotNull ResolveState state) {
  if (aClass == null) {
    return;
  }

  if (!GRADLE_API_CONFIGURATION_CONTAINER.equals(aClass.getQualifiedName())) {
    return;
  }

  // Assuming that the method call is equivalent to calling ConfigurationContainer.getByName()
  processConfigurationAddition(aClass, processor, state, place);
}
 

import com.intellij.psi.scope.PsiScopeProcessor; //导入依赖的package包/类
@Override
public void processDynamicElements(@NotNull PsiType qualifierType,
                                   PsiClass aClass,
                                   @NotNull PsiScopeProcessor processor,
                                   @NotNull PsiElement place,
                                   @NotNull ResolveState state) {
  PsiElement pomElement = aClass.getContainingFile().getContext();
  if (pomElement == null) return;

  PsiFile pomFile = pomElement.getContainingFile();
  if (!(pomFile instanceof XmlFile)) return;

  DomManager domManager = DomManager.getDomManager(pomElement.getProject());
  if (!(domManager.getDomFileDescription((XmlFile)pomFile) instanceof MavenDomProjectModelDescription)) {
    return;
  }

  DynamicMemberUtils.process(processor, false, place, CLASS_SOURCE);
}