import com.intellij.json.JsonLanguage; //导入依赖的package包/类
static SpacingBuilder createSpacingBuilder(CodeStyleSettings settings) {
  final JsonCodeStyleSettings jsonSettings = settings.getCustomSettings(JsonCodeStyleSettings.class);
  final CommonCodeStyleSettings commonSettings = settings.getCommonSettings(JsonLanguage.INSTANCE);

  final int spacesBeforeComma = commonSettings.SPACE_BEFORE_COMMA ? 1 : 0;
  final int spacesBeforeColon = jsonSettings.SPACE_BEFORE_COLON ? 1 : 0;
  final int spacesAfterColon = jsonSettings.SPACE_AFTER_COLON ? 1 : 0;

  return new SpacingBuilder(settings, JsonLanguage.INSTANCE)
    .before(COLON).spacing(spacesBeforeColon, spacesBeforeColon, 0, false, 0)
    .after(COLON).spacing(spacesAfterColon, spacesAfterColon, 0, false, 0)
    .withinPair(L_BRACKET, R_BRACKET).spaceIf(commonSettings.SPACE_WITHIN_BRACKETS, true)
    .withinPair(L_CURLY, R_CURLY).spaceIf(commonSettings.SPACE_WITHIN_BRACES, true)
    .before(COMMA).spacing(spacesBeforeComma, spacesBeforeComma, 0, false, 0)
    .after(COMMA).spaceIf(commonSettings.SPACE_AFTER_COMMA);
}
 

import com.intellij.json.JsonLanguage; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public JsonCodeStylePanel(@NotNull CodeStyleSettings settings) {
  super(JsonLanguage.INSTANCE, null, settings);
  addPanelToWatch(myPanel);
  installPreviewPanel(myPreviewPanel);

  // Initialize combo box with property value alignment types
  for (PropertyAlignment alignment : PropertyAlignment.values()) {
    myPropertiesAlignmentCombo.addItem(alignment);
  }
  myPropertiesAlignmentCombo.setRenderer(new ListCellRendererWrapper<PropertyAlignment>() {
    @Override
    public void customize(JList list, PropertyAlignment value, int index, boolean selected, boolean hasFocus) {
      setText(value.getDescription());
    }
  });
  myPropertiesAlignmentCombo.addItemListener(new ItemListener() {
    @Override
    public void itemStateChanged(ItemEvent e) {
      if (e.getStateChange() == ItemEvent.SELECTED) {
        somethingChanged();
      }
    }
  });
}
 

import com.intellij.json.JsonLanguage; //导入依赖的package包/类
@Override
public void registerReferenceProviders(@NotNull final PsiReferenceRegistrar registrar) {
  registrar.registerReferenceProvider(
      psiElement(PsiLiteralExpression.class).
          withSuperParent(3, psiElement(PsiAnnotation.class)),
      new InjectionReferenceProvider()
  );

  registrar.registerReferenceProvider(
      psiElement(PsiLiteralExpression.class).
          withSuperParent(3, psiElement(PsiAnnotation.class)),
      new InjectorReferenceProvider()
  );

  registrar.registerReferenceProvider(
      psiElement(PsiLiteralExpression.class).
          withLanguage(JavaLanguage.INSTANCE).
          withSuperParent(3, psiElement(PsiAnnotation.class)),
      new MacroReferenceProvider()
  );

  registrar.registerReferenceProvider(
      psiElement(JsonProperty.class).withLanguage(JsonLanguage.INSTANCE),
      new MainClassReferenceProvider()
  );
}
 

import com.intellij.json.JsonLanguage; //导入依赖的package包/类
private PsiElementPattern.Capture<JsonLiteral> localReferencePattern(final String refTypePrefix) {
    return psiElement(JsonLiteral.class)
            .withParent(psiElement(JsonProperty.class).withName(OpenApiConstants.REF_KEY))
            .withText(StandardPatterns.string().contains(refTypePrefix))
            .andNot(StandardPatterns.string().contains(FileConstants.JSON_FILE_NAME_SUFFIX))
            .withLanguage(JsonLanguage.INSTANCE);
}
 

import com.intellij.json.JsonLanguage; //导入依赖的package包/类
private PsiElementPattern.Capture<JsonLiteral> localDefinitionsPattern() {
    return swagger(psiElement(JsonLiteral.class)
            .withParent(psiElement(JsonProperty.class).withName(SwaggerConstants.REF_KEY))
            .withText(StandardPatterns.string().contains(SwaggerConstants.LOCAL_DEFINITIONS_PREFIX))
            .andNot(StandardPatterns.string().contains(FileConstants.JSON_FILE_NAME_SUFFIX))
            .withLanguage(JsonLanguage.INSTANCE));
}
 

import com.intellij.json.JsonLanguage; //导入依赖的package包/类
@Override
public Result preprocessEnter(@NotNull PsiFile file,
                              @NotNull Editor editor,
                              @NotNull Ref<Integer> caretOffsetRef,
                              @NotNull Ref<Integer> caretAdvance,
                              @NotNull DataContext dataContext,
                              EditorActionHandler originalHandler) {
  if (!file.getLanguage().is(JsonLanguage.INSTANCE)) {
    return Result.Continue;
  }
  return super.preprocessEnter(file, editor, caretOffsetRef, caretAdvance, dataContext, originalHandler);
}
 

import com.intellij.json.JsonLanguage; //导入依赖的package包/类
@Nullable
@Override
public CommonCodeStyleSettings getDefaultCommonSettings() {
  CommonCodeStyleSettings commonSettings = new CommonCodeStyleSettings(JsonLanguage.INSTANCE);
  CommonCodeStyleSettings.IndentOptions indentOptions = commonSettings.initIndentOptions();
  indentOptions.INDENT_SIZE = 2;
  // strip all blank lines by default
  commonSettings.KEEP_BLANK_LINES_IN_CODE = 0;
  return commonSettings;
}
 

import com.intellij.json.JsonLanguage; //导入依赖的package包/类
private boolean isInsideCodeBlock(@Nullable PsiElement element) {
  if (element instanceof PsiFileSystemItem) {
    return false;
  }
  if (element == null || element.getParent() == null) {
    return true;
  }
  // Consider all elements of JSON PSI as externally visible, i.e. they are out of code block
  return !(element.getLanguage() instanceof JsonLanguage);
}
 

import com.intellij.json.JsonLanguage; //导入依赖的package包/类
private L10nFileType() {
    super(JsonLanguage.INSTANCE);
}
 

import com.intellij.json.JsonLanguage; //导入依赖的package包/类
private boolean hasJsonRootKey(final PsiFile psiFile, final String lookupKey) {
    final Language language = psiFile.getLanguage();

    return JsonLanguage.INSTANCE.is(language) && new PathFinder().findByPathFrom(lookupKey, psiFile).isPresent();
}
 

import com.intellij.json.JsonLanguage; //导入依赖的package包/类
private PsiElementPattern.Capture<JsonLiteral> filePattern() {
    return psiElement(JsonLiteral.class)
            .withText(endsWithJson())
            .withLanguage(JsonLanguage.INSTANCE);
}
 

import com.intellij.json.JsonLanguage; //导入依赖的package包/类
private PsiElementPattern.Capture<JsonLiteral> componentFileReferencePattern() {
    return psiElement(JsonLiteral.class)
            .withParent(psiElement(JsonProperty.class).withName(OpenApiConstants.REF_KEY))
            .withText(StandardPatterns.string().matches("(.*).json#/([^/])*$"))
            .withLanguage(JsonLanguage.INSTANCE);
}
 

import com.intellij.json.JsonLanguage; //导入依赖的package包/类
private PsiElementPattern.Capture<JsonLiteral> externalDefinitionsInRootPattern() {
    return swagger(psiElement(JsonLiteral.class)
            .withParent(psiElement(JsonProperty.class).withName(SwaggerConstants.REF_KEY))
            .withText(StandardPatterns.string().matches("(.*).json#/([^/])*$"))
            .withLanguage(JsonLanguage.INSTANCE));
}
 

import com.intellij.json.JsonLanguage; //导入依赖的package包/类
private PsiElementPattern.Capture<JsonLiteral> externalDefinitionsNotInRootPattern() {
    return swagger(psiElement(JsonLiteral.class)
            .withParent(psiElement(JsonProperty.class).withName(SwaggerConstants.REF_KEY))
            .withText(StandardPatterns.string().matches("(.*).json#/(.*)/(.*)"))
            .withLanguage(JsonLanguage.INSTANCE));
}
 

import com.intellij.json.JsonLanguage; //导入依赖的package包/类
private PsiElementPattern.Capture<JsonLiteral> localParametersPattern() {
    return swagger(psiElement(JsonLiteral.class).withText(StandardPatterns.string().contains(SwaggerConstants.LOCAL_PARAMETERS_PREFIX))
            .withLanguage(JsonLanguage.INSTANCE));
}
 

import com.intellij.json.JsonLanguage; //导入依赖的package包/类
private PsiElementPattern.Capture<JsonLiteral> localResponsesPattern() {
    return swagger(psiElement(JsonLiteral.class).withText(StandardPatterns.string().contains(SwaggerConstants.LOCAL_RESPONSES_PREFIX))
            .withLanguage(JsonLanguage.INSTANCE));
}
 

import com.intellij.json.JsonLanguage; //导入依赖的package包/类
private PsiElementPattern.Capture<JsonLiteral> filePattern() {
    return swagger(psiElement(JsonLiteral.class)
            .withText(endsWithJson())
            .withLanguage(JsonLanguage.INSTANCE));
}
 

import com.intellij.json.JsonLanguage; //导入依赖的package包/类
private PsiElementPattern.Capture<JsonValue> tagsPattern() {
    return psiElement(JsonValue.class).inside(psiElement(JsonProperty.class).withName(SwaggerConstants.TAGS_KEY))
            .withLanguage(JsonLanguage.INSTANCE);
}
 

import com.intellij.json.JsonLanguage; //导入依赖的package包/类
private StylintConfigFileType() {
    super(JsonLanguage.INSTANCE);
}
 

import com.intellij.json.JsonLanguage; //导入依赖的package包/类
private CommonCodeStyleSettings getCommonSettings() {
  return mySettings.getCommonSettings(JsonLanguage.INSTANCE);
}