Java MultiHostRegistrar类代码示例

import com.intellij.lang.injection.MultiHostRegistrar; //导入依赖的package包/类
@Override
public void getLanguagesToInject(@NotNull final MultiHostRegistrar injectionPlacesRegistrar, @NotNull PsiElement context) {
  final PsiLanguageInjectionHost host = (PsiLanguageInjectionHost)context;
  InjectedLanguagePlaces placesRegistrar = new InjectedLanguagePlaces() {
    @Override
    public void addPlace(@NotNull Language language, @NotNull TextRange rangeInsideHost, @NonNls @Nullable String prefix, @NonNls @Nullable String suffix) {
      injectionPlacesRegistrar
        .startInjecting(language)
        .addPlace(prefix, suffix, host, rangeInsideHost)
        .doneInjecting();
    }
  };
  for (LanguageInjector injector : Extensions.getExtensions(LanguageInjector.EXTENSION_POINT_NAME)) {
    injector.getLanguagesToInject(host, placesRegistrar);
  }
}
 

import com.intellij.lang.injection.MultiHostRegistrar; //导入依赖的package包/类
@Override
@NotNull
public MultiHostRegistrar startInjecting(@NotNull Language language) {
  escapers = new SmartList<LiteralTextEscaper<? extends PsiLanguageInjectionHost>>();
  shreds = new SmartList<PsiLanguageInjectionHost.Shred>();
  outChars = new StringBuilder();

  if (!cleared) {
    clear();
    throw new IllegalStateException("Seems you haven't called doneInjecting()");
  }

  if (LanguageParserDefinitions.INSTANCE.forLanguage(language) == null) {
    ReferenceInjector injector = ReferenceInjector.findById(language.getID());
    if (injector == null) {
      throw new UnsupportedOperationException("Cannot inject language '" + language + "' since its getParserDefinition() returns null");
    }
    myLanguage = null;
    myReferenceInjector = injector;
  }
  myLanguage = language;

  return this;
}
 

import com.intellij.lang.injection.MultiHostRegistrar; //导入依赖的package包/类
@NotNull
private static PyInjectionUtil.InjectionResult registerCommentInjection(@NotNull MultiHostRegistrar registrar,
                                                                        @NotNull PsiLanguageInjectionHost host) {
  final String text = host.getText();
  final Matcher m = PyTypingTypeProvider.TYPE_COMMENT_PATTERN.matcher(text);
  if (m.matches()) {
    final String annotationText = m.group(1);
    if (annotationText != null && isTypingAnnotation(annotationText)) {
      final int start = m.start(1);
      final int end = m.end(1);
      if (start < end && allowInjectionInComment(host)) {
        final Language language = PyDocstringLanguageDialect.getInstance();
        registrar.startInjecting(language);
        registrar.addPlace("", "", host, TextRange.create(start, end));
        registrar.doneInjecting();
        return new PyInjectionUtil.InjectionResult(true, true);
      }
    }
  }
  return PyInjectionUtil.InjectionResult.EMPTY;
}
 

import com.intellij.lang.injection.MultiHostRegistrar; //导入依赖的package包/类
@Override
public void getLanguagesToInject(@NotNull final MultiHostRegistrar registrar, @NotNull final PsiElement host) {
  Pair<ASTNode, ASTNode> pair = parseConditionalCommentBoundaries(host);
  if (pair == null) {
    return;
  }
  final TextRange textRange = host.getTextRange();
  final int startOffset = textRange.getStartOffset();
  Language language = host.getParent().getLanguage();
  ASTNode conditionalStart = pair.first;
  ASTNode conditionalEnd = pair.second;
  TextRange range = new UnfairTextRange(conditionalStart.getTextRange().getEndOffset() - startOffset, conditionalEnd.getStartOffset() - startOffset);
  if (range.getStartOffset() < range.getEndOffset()) {
    registrar.startInjecting(language).addPlace(null, null, (PsiLanguageInjectionHost)host, range).doneInjecting();
  }
}
 

import com.intellij.lang.injection.MultiHostRegistrar; //导入依赖的package包/类
@Override
public void getLanguagesToInject(@NotNull MultiHostRegistrar registrar, @NotNull PsiElement host) {
  if (!host.isValid() || !(host instanceof XmlText) || !HtmlUtil.isHtmlTagContainingFile(host)) {
    return;
  }
  XmlTag scriptTag = ((XmlText)host).getParentTag();

  if (scriptTag == null) {
    return;
  }
  final Language language = getScriptLanguageToInject(scriptTag);

  if (language == null || HtmlScriptInjectionBlockerExtension.isInjectionBlocked(scriptTag, language)) {
    return;
  }

  if (LanguageUtil.isInjectableLanguage(language)) {
    registrar
      .startInjecting(language)
      .addPlace(null, null, (PsiLanguageInjectionHost)host, TextRange.create(0, host.getTextLength()))
      .doneInjecting();
  }
}
 

import com.intellij.lang.injection.MultiHostRegistrar; //导入依赖的package包/类
public void getLanguagesToInject(@NotNull final MultiHostRegistrar registrar, @NotNull final PsiElement context) {
  if (!(context instanceof PsiLanguageInjectionHost) || !((PsiLanguageInjectionHost)context).isValidHost()) return;
  PsiLanguageInjectionHost host = (PsiLanguageInjectionHost)context;

  PsiFile containingFile = context.getContainingFile();
  InjectedLanguage injectedLanguage = myRegistry.getLanguageFor(host, containingFile);
  Language language = injectedLanguage != null ? injectedLanguage.getLanguage() : null;
  if (language == null) return;

  final ElementManipulator<PsiLanguageInjectionHost> manipulator = ElementManipulators.getManipulator(host);
  if (manipulator == null) return;
  List<Trinity<PsiLanguageInjectionHost, InjectedLanguage,TextRange>> trinities =
    Collections.singletonList(Trinity.create(host, injectedLanguage, manipulator.getRangeInElement(host)));
  InjectorUtils.registerInjection(language, trinities, containingFile, registrar);
  InjectorUtils.registerSupport(myRegistry.getLanguageInjectionSupport(), false, registrar);
}
 

import com.intellij.lang.injection.MultiHostRegistrar; //导入依赖的package包/类
public static boolean registerInjectionSimple(@NotNull PsiLanguageInjectionHost host,
                                              @NotNull BaseInjection injection,
                                              @Nullable LanguageInjectionSupport support,
                                              @NotNull MultiHostRegistrar registrar) {
  Language language = InjectedLanguage.findLanguageById(injection.getInjectedLanguageId());
  if (language == null) return false;

  InjectedLanguage injectedLanguage =
    InjectedLanguage.create(injection.getInjectedLanguageId(), injection.getPrefix(), injection.getSuffix(), false);

  List<TextRange> ranges = injection.getInjectedArea(host);
  List<Trinity<PsiLanguageInjectionHost, InjectedLanguage, TextRange>> list = ContainerUtil.newArrayListWithCapacity(ranges.size());

  for (TextRange range : ranges) {
    list.add(Trinity.create(host, injectedLanguage, range));
  }
  //if (host.getChildren().length > 0) {
  //  host.putUserData(LanguageInjectionSupport.HAS_UNPARSABLE_FRAGMENTS, Boolean.TRUE);
  //}
  registerInjection(language, list, host.getContainingFile(), registrar);
  if (support != null) {
    registerSupport(support, true, registrar);
  }
  return !ranges.isEmpty();
}
 

import com.intellij.lang.injection.MultiHostRegistrar; //导入依赖的package包/类
public static void registerInjection(Language language, List<Trinity<PsiLanguageInjectionHost, InjectedLanguage, TextRange>> list, PsiFile containingFile, MultiHostRegistrar registrar) {
  // if language isn't injected when length == 0, subsequent edits will not cause the language to be injected as well.
  // Maybe IDEA core is caching a bit too aggressively here?
  if (language == null/* && (pair.second.getLength() > 0*/) {
    return;
  }
  boolean injectionStarted = false;
  for (Trinity<PsiLanguageInjectionHost, InjectedLanguage, TextRange> trinity : list) {
    final PsiLanguageInjectionHost host = trinity.first;
    if (host.getContainingFile() != containingFile) continue;

    final TextRange textRange = trinity.third;
    final InjectedLanguage injectedLanguage = trinity.second;

    if (!injectionStarted) {
      registrar.startInjecting(language);
      injectionStarted = true;
    }
    registrar.addPlace(injectedLanguage.getPrefix(), injectedLanguage.getSuffix(), host, textRange);
  }
  if (injectionStarted) {
    registrar.doneInjecting();
  }
}
 

import com.intellij.lang.injection.MultiHostRegistrar; //导入依赖的package包/类
public void getLanguagesToInject(@NotNull final MultiHostRegistrar registrar, @NotNull final PsiElement context) {
  if (!(context instanceof PsiLanguageInjectionHost) || context instanceof PsiComment) return;
  if (!((PsiLanguageInjectionHost)context).isValidHost()) return;
  PsiLanguageInjectionHost host = (PsiLanguageInjectionHost)context;

  boolean applicableFound = false;
  for (LanguageInjectionSupport support : mySupports) {
    if (!support.isApplicableTo(host)) continue;
    if (support == myInjectorSupport && applicableFound) continue;
    applicableFound = true;

    BaseInjection injection = support.findCommentInjection(host, null);
    if (injection == null) continue;
    if (!InjectorUtils.registerInjectionSimple(host, injection, support, registrar)) continue;
    return;
  }
}
 

import com.intellij.lang.injection.MultiHostRegistrar; //导入依赖的package包/类
public void getLanguagesToInject(@NotNull final MultiHostRegistrar registrar, @NotNull final PsiElement host) {
  if (SCRIPT_PATTERN.accepts(host)) {
    final List<String> registeredLanguages = JavaFxPsiUtil.parseInjectedLanguages((XmlFile)host.getContainingFile());
    for (Language language : Language.getRegisteredLanguages()) {
      for (String registeredLanguage : registeredLanguages) {
        if (StringUtil.equalsIgnoreCase(language.getID(), registeredLanguage)) {
          registrar.startInjecting(language)
            .addPlace(null, null, (PsiLanguageInjectionHost) host,
                      TextRange.from(0, host.getTextLength() - 1))
            .doneInjecting();
          break;
        }
      }
    }
  }
}
 

import com.intellij.lang.injection.MultiHostRegistrar; //导入依赖的package包/类
@Override
public void getLanguagesToInject(@NotNull final MultiHostRegistrar injectionPlacesRegistrar, @NotNull PsiElement context) {
  final PsiLanguageInjectionHost host = (PsiLanguageInjectionHost)context;
  InjectedLanguagePlaces placesRegistrar = new InjectedLanguagePlaces() {
    @Override
    public void addPlace(@NotNull Language language, @NotNull TextRange rangeInsideHost, @NonNls @Nullable String prefix, @NonNls @Nullable String suffix) {
      ProperTextRange.assertProperRange(rangeInsideHost);
      injectionPlacesRegistrar
        .startInjecting(language)
        .addPlace(prefix, suffix, host, rangeInsideHost)
        .doneInjecting();
    }
  };
  for (LanguageInjector injector : Extensions.getExtensions(LanguageInjector.EXTENSION_POINT_NAME)) {
    injector.getLanguagesToInject(host, placesRegistrar);
  }
}
 

import com.intellij.lang.injection.MultiHostRegistrar; //导入依赖的package包/类
@Override
@NotNull
public MultiHostRegistrar startInjecting(@NotNull Language language) {
  escapers = new SmartList<LiteralTextEscaper<? extends PsiLanguageInjectionHost>>();
  shreds = new SmartList<PsiLanguageInjectionHost.Shred>();
  outChars = new StringBuilder();

  if (!cleared) {
    clear();
    throw new IllegalStateException("Seems you haven't called doneInjecting()");
  }

  if (LanguageParserDefinitions.INSTANCE.forLanguage(language) == null) {
    throw new UnsupportedOperationException("Cannot inject language '" + language + "' since its getParserDefinition() returns null");
  }
  myLanguage = language;

  return this;
}
 

import com.intellij.lang.injection.MultiHostRegistrar; //导入依赖的package包/类
public static boolean registerInjectionSimple(@NotNull PsiLanguageInjectionHost host,
                                              @NotNull BaseInjection injection,
                                              @Nullable LanguageInjectionSupport support,
                                              @NotNull MultiHostRegistrar registrar) {
  Language language = InjectedLanguage.findLanguageById(injection.getInjectedLanguageId());
  if (language == null) return false;

  InjectedLanguage injectedLanguage =
    InjectedLanguage.create(injection.getInjectedLanguageId(), injection.getPrefix(), injection.getSuffix(), false);

  List<TextRange> ranges = injection.getInjectedArea(host);
  List<Trinity<PsiLanguageInjectionHost, InjectedLanguage, TextRange>> list = ContainerUtil.newArrayListWithExpectedSize(ranges.size());

  for (TextRange range : ranges) {
    list.add(Trinity.create(host, injectedLanguage, range));
  }
  //if (host.getChildren().length > 0) {
  //  host.putUserData(LanguageInjectionSupport.HAS_UNPARSABLE_FRAGMENTS, Boolean.TRUE);
  //}
  registerInjection(language, list, host.getContainingFile(), registrar);
  if (support != null) {
    registerSupport(support, true, registrar);
  }
  return !ranges.isEmpty();
}
 

import com.intellij.lang.injection.MultiHostRegistrar; //导入依赖的package包/类
public void getLanguagesToInject(@NotNull final MultiHostRegistrar registrar, @NotNull final PsiElement context) {
  if (!(context instanceof PsiLanguageInjectionHost) || !((PsiLanguageInjectionHost)context).isValidHost()) return;
  PsiLanguageInjectionHost host = (PsiLanguageInjectionHost)context;

  boolean applicableFound = false;
  for (LanguageInjectionSupport support : mySupports) {
    if (!support.isApplicableTo(host)) continue;
    if (support == myInjectorSupport && applicableFound) continue;
    applicableFound = true;

    BaseInjection injection = support.findCommentInjection(host, null);
    if (injection == null) continue;
    if (!InjectorUtils.registerInjectionSimple(host, injection, support, registrar)) continue;
    return;
  }
}
 

import com.intellij.lang.injection.MultiHostRegistrar; //导入依赖的package包/类
private static void processAnnotations(MultiHostRegistrar registrar,
                                       PsiLanguageInjectionHost host,
                                       PsiModifierListOwner annotationOwner) {
  final Pair<String, ? extends Set<String>> pair =
    Configuration.getInstance().getAdvancedConfiguration().getLanguageAnnotationPair();

  final PsiAnnotation[] annotations = getAnnotationFrom(annotationOwner, pair, true, true);
  if (annotations.length > 0) {
    BaseInjection injection = new BaseInjection(GroovyLanguageInjectionSupport.GROOVY_SUPPORT_ID);

    injection.setPrefix(StringUtil.notNullize(AnnotationUtilEx.calcAnnotationValue(annotations, "prefix")));
    injection.setSuffix(StringUtil.notNullize(AnnotationUtilEx.calcAnnotationValue(annotations, "suffix")));
    injection.setInjectedLanguageId(StringUtil.notNullize(AnnotationUtilEx.calcAnnotationValue(annotations, "value")));

    LanguageInjectionSupport support = InjectorUtils.findInjectionSupport(GroovyLanguageInjectionSupport.GROOVY_SUPPORT_ID);
    InjectorUtils.registerInjectionSimple(host, injection, support, registrar);
  }
}