Java ProcessingContext.get方法代码示例

import com.intellij.util.ProcessingContext; //导入方法依赖的package包/类
@Override
protected void addCompletions(@NotNull CompletionParameters parameters,
                              ProcessingContext processingContext,
                              @NotNull CompletionResultSet result) {

    final PsiElement original = parameters.getOriginalPosition();
    if (original != null) {
        result = result.withPrefixMatcher(getPrefix(parameters.getOffset(), parameters.getOriginalFile()));
        SyntheticTypeInfo sti = processingContext.get(SYNTHETIC_TYPE_INFO_KEY);
        if (sti.hasSyntheticConstructor()) {
            for (SyntheticMemberInfo smi : sti.getMembers()) {
                LookupElement lookupElement =
                        LookupElementBuilder
                                .create(smi.getName() + "=")
                                .withIcon(PlatformIcons.PARAMETER_ICON);
                result.addElement(lookupElement);
            }
        }
    }
}
 

import com.intellij.util.ProcessingContext; //导入方法依赖的package包/类
private static void addUnfinishedMethodTypeParameters(PsiElement position, final Consumer<LookupElement> result) {
  final ProcessingContext context = new ProcessingContext();
  if (psiElement().inside(
    psiElement(PsiTypeElement.class).afterLeaf(
      psiElement().withText(">").withParent(
        psiElement(PsiTypeParameterList.class).withParent(PsiErrorElement.class).save("typeParameterList")))).accepts(position, context)) {
    final PsiTypeParameterList list = (PsiTypeParameterList)context.get("typeParameterList");
    PsiElement current = list.getParent().getParent();
    if (current instanceof PsiField) {
      current = current.getParent();
    }
    if (current instanceof PsiClass) {
      for (PsiTypeParameter typeParameter : list.getTypeParameters()) {
        result.consume(new JavaPsiClassReferenceElement(typeParameter));
      }
    }
  }
}
 

import com.intellij.util.ProcessingContext; //导入方法依赖的package包/类
@Nullable
public static WeighingComparable<PsiElement, ProximityLocation> getProximity(final Computable<PsiElement> elementComputable, final PsiElement context, ProcessingContext processingContext) {
  PsiElement element = elementComputable.compute();
  if (element == null) return null;
  if (element instanceof MetadataPsiElementBase) return null;
  if (context == null) return null;
  Module contextModule = processingContext.get(MODULE_BY_LOCATION);
  if (contextModule == null) {
    contextModule = ModuleUtilCore.findModuleForPsiElement(context);
    processingContext.put(MODULE_BY_LOCATION, contextModule);
  }

  if (contextModule == null) return null;

  return new WeighingComparable<PsiElement,ProximityLocation>(elementComputable,
                                                              new ProximityLocation(context, contextModule, processingContext),
                                                              PROXIMITY_WEIGHERS);
}
 

import com.intellij.util.ProcessingContext; //导入方法依赖的package包/类
@Override
public PsiElement resolve() {
  final ProcessingContext context = new ProcessingContext();
  final ResolvingVisitor visitor = new ResolvingVisitor(PATTERN.with(myCondition).save(TARGET), context) {
    @Override
    public void visitXmlTag(XmlTag tag) {
      super.visitXmlTag(tag);
      if (shouldContinue()) {
        visitSubTags(tag);
      }
    }
    @Override
    protected boolean shouldContinue() {
      return context.get(TARGET) == null;
    }
  };

  process(visitor);

  return context.get(TARGET);
}
 

import com.intellij.util.ProcessingContext; //导入方法依赖的package包/类
@Override
protected void addCompletions(@NotNull CompletionParameters parameters,
                              ProcessingContext context,
                              @NotNull CompletionResultSet result) {
    List<SyntheticTypeInfo> typeInfoList = context.get(SYNTHETIC_TYPE_INFO_KEY);

    for (SyntheticTypeInfo typeInfo : typeInfoList) {
        result.addAllElements(typeInfo.getLookupElements());
    }
}
 

import com.intellij.util.ProcessingContext; //导入方法依赖的package包/类
private static boolean isAfterExpression(PsiElement element) {
  ProcessingContext context = new ProcessingContext();
  if (psiElement().withAncestor(1, instanceOf(PsiExpression.class))
    .afterLeaf(psiElement().withAncestor(1, psiElement(PsiExpression.class).save("prevExpr"))).accepts(element, context)) {
    PsiExpression prevExpr = (PsiExpression)context.get("prevExpr");
    if (prevExpr.getTextRange().getEndOffset() <= element.getTextRange().getStartOffset()) {
      return true;
    }
  }

  return false;
}
 

import com.intellij.util.ProcessingContext; //导入方法依赖的package包/类
@NotNull
@Override
public PsiReference[] getReferencesByElement(@NotNull PsiElement element, @NotNull ProcessingContext context) {

  if (XmlSchemaTagsProcessor.PROCESSING_FLAG.get() != null || context.get(SUPPRESS) != null) {
    return PsiReference.EMPTY_ARRAY;
  }
  @SuppressWarnings("unchecked") PsiElement host = getHost((T)element);
  if (host instanceof PsiLanguageInjectionHost && InjectedLanguageUtil.hasInjections((PsiLanguageInjectionHost)host)) {
    return PsiReference.EMPTY_ARRAY;
  }
  String unquotedValue = ElementManipulators.getValueText(element);
  if (XmlHighlightVisitor.skipValidation(element) || !XmlUtil.isSimpleValue(unquotedValue, element)) {
    return PsiReference.EMPTY_ARRAY;
  }
  @SuppressWarnings("unchecked") final Object descriptor = getDescriptor((T)element);
  if (descriptor instanceof XmlEnumerationDescriptor) {
    XmlEnumerationDescriptor enumerationDescriptor = (XmlEnumerationDescriptor)descriptor;

    if (enumerationDescriptor.isFixed() || enumerationDescriptor.isEnumerated((XmlElement)element)) {
      //noinspection unchecked
      return enumerationDescriptor.getValueReferences((XmlElement)element, unquotedValue);
    }
    else if (unquotedValue.equals(enumerationDescriptor.getDefaultValue())) {  // todo case insensitive
      return ContainerUtil.map2Array(enumerationDescriptor.getValueReferences((XmlElement)element, unquotedValue), PsiReference.class,
                                     new Function<PsiReference, PsiReference>() {
                                       @Override
                                       public PsiReference fun(PsiReference reference) {
                                         return PsiDelegateReference.createSoft(reference, true);
                                       }
                                     });
    }
  }
  return PsiReference.EMPTY_ARRAY;
}
 

import com.intellij.util.ProcessingContext; //导入方法依赖的package包/类
@NotNull
public static PsiType findPsiType(GroovyClassDescriptor descriptor, ProcessingContext ctx) {
  String typeText = descriptor.getTypeText();
  final String key = getClassKey(typeText);
  final Object cached = ctx.get(key);
  if (cached instanceof PsiType) {
    return (PsiType)cached;
  }

  final PsiType found = JavaPsiFacade.getElementFactory(descriptor.getProject()).createTypeFromText(typeText, descriptor.getPlaceFile());
  ctx.put(key, found);
  return found;
}
 

import com.intellij.util.ProcessingContext; //导入方法依赖的package包/类
private static boolean isAfterExpression(PsiElement element) {
  ProcessingContext context = new ProcessingContext();
  if (PlatformPatterns.psiElement().afterLeaf(
    PlatformPatterns.psiElement().inside(PlatformPatterns.psiElement(GrExpression.class).save("prevExpr"))).accepts(element, context)) {
    PsiElement prevExpr = (PsiElement)context.get("prevExpr");
    if (prevExpr.getTextRange().getEndOffset() <= element.getTextRange().getStartOffset()) {
      return true;
    }
  }
  return false;
}
 

import com.intellij.util.ProcessingContext; //导入方法依赖的package包/类
public Object[] getCompletionVariants(String prefix, PsiElement location, ProcessingContext context) {
  Set<PyClassType> visited = context.get(CTX_VISITED);
  if (visited == null) {
    visited = new HashSet<PyClassType>();
    context.put(CTX_VISITED, visited);
  }
  if (visited.contains(this)) {
    return ArrayUtil.EMPTY_OBJECT_ARRAY;
  }
  visited.add(this);
  Set<String> namesAlready = context.get(CTX_NAMES);
  if (namesAlready == null) {
    namesAlready = new HashSet<String>();
  }
  List<Object> ret = new ArrayList<Object>();

  boolean suppressParentheses = context.get(CTX_SUPPRESS_PARENTHESES) != null;
  addOwnClassMembers(location, namesAlready, suppressParentheses, ret);

  PsiFile origin = (location != null) ?
                   CompletionUtil.getOriginalOrSelf(location)
                     .getContainingFile() :
                   null;
  final TypeEvalContext typeEvalContext = TypeEvalContext.codeCompletion(myClass.getProject(), origin);
  addInheritedMembers(prefix, location, namesAlready, context, ret, typeEvalContext);

  // from providers
  for (final PyClassMembersProvider provider : Extensions.getExtensions(PyClassMembersProvider.EP_NAME)) {
    for (final PyCustomMember member : provider.getMembers(this, location)) {
      final String name = member.getName();
      if (!namesAlready.contains(name)) {
        ret.add(PyCustomMemberUtils.toLookUpElement(member, getName()));
      }
    }
  }

  if (!myClass.isNewStyleClass(null)) {
    final PyBuiltinCache cache = PyBuiltinCache.getInstance(myClass);
    final PyClassType classobjType = cache.getOldstyleClassobjType();
    if (classobjType != null) {
      ret.addAll(Arrays.asList(classobjType.getCompletionVariants(prefix, location, context)));
    }
  }

  if (isDefinition() && myClass.isNewStyleClass(null)) {
    final PyClassLikeType typeType = getMetaClassType(typeEvalContext, true);
    if (typeType != null) {
      Collections.addAll(ret, typeType.getCompletionVariants(prefix, location, context));
    }
  }

  return ret.toArray();
}