Java ArrayUtil.mergeArrays方法代码示例

import com.intellij.util.ArrayUtil; //导入方法依赖的package包/类
@NotNull
@Override
public ResolveResult[] multiResolve(final boolean incompleteCode) {
    final Project project = myElement.getProject();
    final String modelName = PATTERN.matcher(myElement.getText()).replaceAll("");

    final String javaModelName = modelName + JAVA_MODEL_SUFFIX;
    final String jaloModelName = modelName;

    final PsiClass[] javaModelClasses = PsiShortNamesCache.getInstance(project).getClassesByName(
        javaModelName, GlobalSearchScope.allScope(project)
    );

    final PsiClass[] jaloModelClasses = PsiShortNamesCache.getInstance(project).getClassesByName(
        jaloModelName, GlobalSearchScope.projectScope(project)
    );

    final PsiClass[] psiClasses = ArrayUtil.mergeArrays(javaModelClasses, jaloModelClasses);
    return PsiElementResolveResult.createResults(psiClasses);
}
 

import com.intellij.util.ArrayUtil; //导入方法依赖的package包/类
private String[] doGetKeywords(PsiElement context) {
  final PsiElement next = PsiTreeUtil.skipSiblingsForward(context, PsiWhiteSpace.class);
  if (next != null && EscapeUtil.unescapeText(next).equals("=")) {
      return new String[]{ "start" };
    }

  if (DEFAULT_PATTERN.accepts(context)) {
    return new String[]{ "namespace" };
  } else if (DECL_PATTERN.accepts(context)) {
    return ArrayUtil.EMPTY_STRING_ARRAY;
  } else if (context.getParent() instanceof RncDefine && context.getParent().getFirstChild() == context) {
    if (DEFINE_PATTERN.accepts(context)) {
      return ArrayUtil.EMPTY_STRING_ARRAY;
    }
    if (TOP_LEVEL.accepts(context)) {
      if (!afterPattern(context)) {
        return ArrayUtil.mergeArrays(DECL_KEYWORDS, ArrayUtil.mergeArrays(GRAMMAR_CONTENT_KEYWORDS, PATTERN_KEYWORDS));
      }
    }
    return GRAMMAR_CONTENT_KEYWORDS;
  }
  return PATTERN_KEYWORDS;
}
 

import com.intellij.util.ArrayUtil; //导入方法依赖的package包/类
private static void generateAnnotations(@NonNls @NotNull StringBuilder buffer,
                                        @NotNull PsiModifierListOwner owner,
                                        boolean generateLink,
                                        boolean splitAnnotations,
                                        boolean useShortNames) {
  final PsiModifierList ownerModifierList = owner.getModifierList();
  if (ownerModifierList == null) return;
  generateAnnotations(buffer, owner, ownerModifierList.getAnnotations(), false, generateLink, splitAnnotations, useShortNames);
  PsiAnnotation[] externalAnnotations = ExternalAnnotationsManager.getInstance(owner.getProject()).findExternalAnnotations(owner);
  if (externalAnnotations == null) {
    externalAnnotations = new PsiAnnotation[]{};
  }
  PsiAnnotation[] inferredAnnotations = InferredAnnotationsManager.getInstance(owner.getProject()).findInferredAnnotations(owner);
  externalAnnotations = ArrayUtil.mergeArrays(externalAnnotations, inferredAnnotations, PsiAnnotation.ARRAY_FACTORY);
  generateAnnotations(buffer, owner, externalAnnotations, true, generateLink, splitAnnotations, useShortNames);
}
 

import com.intellij.util.ArrayUtil; //导入方法依赖的package包/类
@NotNull
public ResolveResult[] multiResolve(@NotNull Project project) {
  List<ResolveResult> typeDefs =
      SchemaIndexUtil.findTypeDefs(project, prefixes, suffix, searchScope).stream()
      .filter(Objects::nonNull)
      .map(PsiElementResolveResult::new)
      .collect(Collectors.toList());

  // see comment in `resolve` above re. namespace declaration reference

  Qn prefix = input;
  int prefixLength = prefix.size();
  List<SchemaNamespaceDecl> namespaceDecls = resolveNamespaces(project, prefix);

  ResolveResult[] namespaces = namespaceDecls.stream()
      .map(ns -> new PsiElementResolveResult(getTargetSegment(ns, prefixLength)))
      .toArray(ResolveResult[]::new);

  return ArrayUtil.mergeArrays(typeDefs.toArray(new ResolveResult[typeDefs.size()]), namespaces);
}
 

import com.intellij.util.ArrayUtil; //导入方法依赖的package包/类
private static void doAdd(CompletionParameters parameters, final CompletionResultSet result) {
  PsiElement position = parameters.getPosition();
  PsiReference[] references = ArrayUtil.mergeArrays(position.getReferences(), position.getParent().getReferences());
  PropertyReference propertyReference = ContainerUtil.findInstance(references, PropertyReference.class);
  if (propertyReference != null && !hasMoreImportantReference(references, propertyReference)) {
    final int startOffset = parameters.getOffset();
    PsiElement element = propertyReference.getElement();
    final int offsetInElement = startOffset - element.getTextRange().getStartOffset();
    TextRange range = propertyReference.getRangeInElement();
    if (offsetInElement >= range.getStartOffset()) {
      final String prefix = element.getText().substring(range.getStartOffset(), offsetInElement);

      LookupElement[] variants = getVariants(propertyReference);
      result.withPrefixMatcher(prefix).addAllElements(Arrays.asList(variants));
    }
  }
}
 

import com.intellij.util.ArrayUtil; //导入方法依赖的package包/类
@Override
public XmlAttributeDescriptor[] getAttributesDescriptors(@Nullable XmlTag context) {
  XmlAttributeDescriptor[] attributeDescriptors = HtmlNSDescriptorImpl.getCommonAttributeDescriptors(context);
  XmlAttributeDescriptor[] customAttributes = new XmlAttributeDescriptor[1];
  customAttributes[0] = new AnyXmlAttributeDescriptor("cat-store");
  return ArrayUtil.mergeArrays(attributeDescriptors, customAttributes);
}
 

import com.intellij.util.ArrayUtil; //导入方法依赖的package包/类
protected GlobalInspectionContextImpl runTool(final String testDir,
                                              final String jdkName,
                                              boolean runDeadCodeFirst,
                                              @NotNull InspectionToolWrapper toolWrapper,
                                              @NotNull InspectionToolWrapper... additional) {
  final VirtualFile[] sourceDir = new VirtualFile[1];
  ApplicationManager.getApplication().runWriteAction(new Runnable() {
    @Override
    public void run() {
      try {
        setupRootModel(testDir, sourceDir, jdkName);
      }
      catch (Exception e) {
        LOG.error(e);
      }
    }
  });
  AnalysisScope scope = createAnalysisScope(sourceDir[0].getParent());

  InspectionManagerEx inspectionManager = (InspectionManagerEx)InspectionManager.getInstance(getProject());
  InspectionToolWrapper[] toolWrappers = runDeadCodeFirst ? new InspectionToolWrapper []{getUnusedDeclarationWrapper(), toolWrapper} : new InspectionToolWrapper []{toolWrapper};
  toolWrappers = ArrayUtil.mergeArrays(toolWrappers, additional);
  final GlobalInspectionContextForTests globalContext =
    CodeInsightTestFixtureImpl.createGlobalContextForTool(scope, getProject(), inspectionManager, toolWrappers);

  InspectionTestUtil.runTool(toolWrapper, scope, globalContext);
  return globalContext;
}
 

import com.intellij.util.ArrayUtil; //导入方法依赖的package包/类
static String suggestUniqueParameterName(JavaCodeStyleManager codeStyleManager,
                                         PsiExpression expression,
                                         PsiType exprType,
                                         Set<String> existingNames) {
  SuggestedNameInfo nameInfo = codeStyleManager.suggestVariableName(VariableKind.PARAMETER, null, expression, exprType);
  @NonNls String[] names = nameInfo.names;
  if (expression instanceof PsiReferenceExpression) {
    final PsiElement resolve = ((PsiReferenceExpression)expression).resolve();
    if (resolve instanceof PsiVariable) {
      final VariableKind variableKind = codeStyleManager.getVariableKind((PsiVariable)resolve);
      final String propertyName = codeStyleManager.variableNameToPropertyName(((PsiVariable)resolve).getName(), variableKind);
      final String parameterName = codeStyleManager.propertyNameToVariableName(propertyName, VariableKind.PARAMETER);
      names = ArrayUtil.mergeArrays(new String[]{parameterName}, names);
    }
  }
  if (names.length == 0) names = new String[]{"param"};
  int suffix = 0;
  while (true) {
    for (String name : names) {
      String suggested = name + (suffix == 0 ? "" : String.valueOf(suffix));
      if (existingNames.add(suggested)) {
        return suggested;
      }
    }
    suffix++;
  }
}
 

import com.intellij.util.ArrayUtil; //导入方法依赖的package包/类
private static PsiDocTag[] getThrowsTags(PsiDocComment comment) {
  if (comment == null) {
    return PsiDocTag.EMPTY_ARRAY;
  }

  PsiDocTag[] tags1 = comment.findTagsByName(THROWS_KEYWORD);
  PsiDocTag[] tags2 = comment.findTagsByName("exception");

  return ArrayUtil.mergeArrays(tags1, tags2);
}
 

import com.intellij.util.ArrayUtil; //导入方法依赖的package包/类
@Override
@NotNull
public Object[] getVariants() {
  PsiElement context = getCompletionContext();
  if (context instanceof PsiPackage) {
    return processPackage((PsiPackage)context);
  }
  if (context instanceof PsiClass) {
    final PsiClass aClass = (PsiClass)context;

    if (myInStaticImport) {
      return ArrayUtil.mergeArrays(aClass.getInnerClasses(), aClass.getFields(), ArrayUtil.OBJECT_ARRAY_FACTORY);
    }
    else if (isDefinitelyStatic()) {
      final PsiClass[] psiClasses = aClass.getInnerClasses();
      final List<PsiClass> staticClasses = new ArrayList<PsiClass>(psiClasses.length);

      for (PsiClass c : psiClasses) {
        if (c.hasModifierProperty(PsiModifier.STATIC)) {
          staticClasses.add(c);
        }
      }
      return staticClasses.isEmpty() ? PsiClass.EMPTY_ARRAY : staticClasses.toArray(new PsiClass[staticClasses.size()]);
    }
  }
  return ArrayUtil.EMPTY_OBJECT_ARRAY;
}
 

import com.intellij.util.ArrayUtil; //导入方法依赖的package包/类
@Override
public String[] getSuperClassNames() {
  final GrTypeDefinitionStub stub = getStub();
  if (stub != null) {
    return stub.getSuperClassNames();
  }
  return ArrayUtil.mergeArrays(getExtendsNames(), getImplementsNames());
}
 

import com.intellij.util.ArrayUtil; //导入方法依赖的package包/类
public static String[] appendUnresolvedExprName(String[] names, final PsiExpression expr) {
  if (expr instanceof PsiReferenceExpression && ((PsiReferenceExpression)expr).resolve() == null) {
    final String name = expr.getText();
    if (PsiNameHelper.getInstance(expr.getProject()).isIdentifier(name, LanguageLevel.HIGHEST)) {
      names = ArrayUtil.mergeArrays(new String[]{name}, names);
    }
  }
  return names;
}
 

import com.intellij.util.ArrayUtil; //导入方法依赖的package包/类
@Override
@NotNull
public XmlElementDescriptor[] getRootElementsDescriptors(@Nullable final XmlDocument doc) {
  final XmlElementDescriptor[] descriptors = super.getRootElementsDescriptors(doc);
  /**
   * HTML 5 descriptor list contains not only HTML elements, but also SVG and MathML. To prevent conflicts
   * we need to prioritize HTML ones {@link org.intellij.html.RelaxedHtmlFromRngElementDescriptor#compareTo(Object)}
   */
  Arrays.sort(descriptors);
  return ArrayUtil.mergeArrays(descriptors, HtmlUtil.getCustomTagDescriptors(doc));
}
 

import com.intellij.util.ArrayUtil; //导入方法依赖的package包/类
@Override
@NotNull
public GrField[] getFields() {
  GrField[] bodyFields = super.getFields();
  GrEnumConstant[] enumConstants = getEnumConstants();
  if (bodyFields.length == 0) return enumConstants;
  if (enumConstants.length == 0) return bodyFields;
  return ArrayUtil.mergeArrays(bodyFields, enumConstants);
}
 

import com.intellij.util.ArrayUtil; //导入方法依赖的package包/类
private static void fillResultsMap(Map<PsiFile, PsiClass[]> result, PsiFile containingFile, PsiClass[] topLevelClasses) {
  PsiClass[] classes = result.get(containingFile);
  if (topLevelClasses != null) {
    if (classes != null) {
      topLevelClasses = ArrayUtil.mergeArrays(classes, topLevelClasses, PsiClass.ARRAY_FACTORY);
    }
    result.put(containingFile, topLevelClasses);
  } else {
    result.put(containingFile, classes);
  }
}