Java BuildMessage类代码示例

import org.jetbrains.jps.incremental.messages.BuildMessage; //导入依赖的package包/类
public void outputLineAvailable(String line) {
  if (!StringUtil.isEmpty(line)) {
    if (line.startsWith(ExternalJavacManager.STDOUT_LINE_PREFIX)) {
      //noinspection UseOfSystemOutOrSystemErr
      System.out.println(line);
    }
    else if (line.startsWith(ExternalJavacManager.STDERR_LINE_PREFIX)) {
      //noinspection UseOfSystemOutOrSystemErr
      System.err.println(line);
    }
    else if (line.contains("java.lang.OutOfMemoryError")) {
      myContext.processMessage(new CompilerMessage(BUILDER_NAME, BuildMessage.Kind.ERROR, "OutOfMemoryError: insufficient memory"));
      myErrorCount++;
    }
    else {
      final BuildMessage.Kind kind = getKindByMessageText(line);
      if (kind == BuildMessage.Kind.ERROR) {
        myErrorCount++;
      }
      else if (kind == BuildMessage.Kind.WARNING) {
        myWarningCount++;
      }
      myContext.processMessage(new CompilerMessage(BUILDER_NAME, kind, line));
    }
  }
}
 

import org.jetbrains.jps.incremental.messages.BuildMessage; //导入依赖的package包/类
@Nullable
private JarInfo[] sortJars() {
  final DFSTBuilder<JarInfo> builder = new DFSTBuilder<JarInfo>(GraphGenerator.create(CachingSemiGraph.create(new JarsGraph())));
  if (!builder.isAcyclic()) {
    final Pair<JarInfo, JarInfo> dependency = builder.getCircularDependency();
    String message = "Cannot build: circular dependency found between '" + dependency.getFirst().getPresentableDestination() +
                     "' and '" + dependency.getSecond().getPresentableDestination() + "'";
    myContext.processMessage(new CompilerMessage(IncArtifactBuilder.BUILDER_NAME, BuildMessage.Kind.ERROR, message));
    return null;
  }

  JarInfo[] jars = myJarsToBuild.toArray(new JarInfo[myJarsToBuild.size()]);
  Arrays.sort(jars, builder.comparator());
  jars = ArrayUtil.reverseArray(jars);
  return jars;
}
 

import org.jetbrains.jps.incremental.messages.BuildMessage; //导入依赖的package包/类
@Nullable
private Manifest createManifest(InputStream manifestStream, File manifestFile) {
  try {
    try {
      return new Manifest(manifestStream);
    }
    finally {
      manifestStream.close();
    }
  }
  catch (IOException e) {
    myContext.processMessage(new CompilerMessage(IncArtifactBuilder.BUILDER_NAME, BuildMessage.Kind.ERROR,
                                                 "Cannot create MANIFEST.MF from " + manifestFile.getAbsolutePath() + ":" + e.getMessage()));
    LOG.debug(e);
    return null;
  }
}
 

import org.jetbrains.jps.incremental.messages.BuildMessage; //导入依赖的package包/类
@Override
@Nullable
protected BinaryContent instrument(CompileContext context,
                                   CompiledClass compiledClass,
                                   ClassReader reader,
                                   ClassWriter writer,
                                   InstrumentationClassFinder finder) {
  try {
    if (NotNullVerifyingInstrumenter.processClassFile(reader, writer)) {
      return new BinaryContent(writer.toByteArray());
    }
  }
  catch (Throwable e) {
    final StringBuilder msg = new StringBuilder();
    msg.append("@NotNull instrumentation failed ");
    final File sourceFile = compiledClass.getSourceFile();
    msg.append(" for ").append(sourceFile.getName());
    msg.append(": ").append(e.getMessage());
    context.processMessage(new CompilerMessage(getPresentableName(), BuildMessage.Kind.ERROR, msg.toString(), sourceFile.getPath()));
  }
  return null;
}
 

import org.jetbrains.jps.incremental.messages.BuildMessage; //导入依赖的package包/类
@NotNull
public static JpsSdk<JpsDummyElement> ensureModuleHasJdk(JpsModule module, CompileContext context, final String compilerName) throws
                                                                                                                              ProjectBuildException {
  JpsSdkReference<JpsDummyElement> reference = module.getSdkReference(JpsJavaSdkType.INSTANCE);
  if (reference == null) {
    context.processMessage(new CompilerMessage(compilerName, BuildMessage.Kind.ERROR, "JDK isn't specified for module '" + module.getName() + "'"));
    throw new StopBuildException();
  }

  JpsTypedLibrary<JpsSdk<JpsDummyElement>> sdkLibrary = reference.resolve();
  if (sdkLibrary == null) {
    context.processMessage(new CompilerMessage(compilerName, BuildMessage.Kind.ERROR,
                                               "Cannot find JDK '" + reference.getSdkName() + "' for module '" + module.getName() + "'"));
    throw new StopBuildException();
  }
  return sdkLibrary.getProperties();
}
 

import org.jetbrains.jps.incremental.messages.BuildMessage; //导入依赖的package包/类
@Override
public void processMessage(BuildMessage msg) {
  if (msg.getKind() == BuildMessage.Kind.ERROR) {
    myErrorMessages.add(msg);
    myUpToDate = false;
  }
  else if (msg.getKind() == BuildMessage.Kind.WARNING) {
    myWarnMessages.add(msg);
  }
  else {
    myInfoMessages.add(msg);
  }
  if (msg instanceof DoneSomethingNotification) {
    myUpToDate = false;
  }
}
 

import org.jetbrains.jps.incremental.messages.BuildMessage; //导入依赖的package包/类
public static void addMessages(@NotNull CompileContext context,
                               @NotNull Map<AndroidCompilerMessageKind, List<String>> messages,
                               @NotNull String builderName,
                               @NotNull String entryName) {
  for (Map.Entry<AndroidCompilerMessageKind, List<String>> entry : messages.entrySet()) {
    for (String message : entry.getValue()) {
      String filePath = null;
      int line = -1;
      final Matcher matcher = AndroidCommonUtils.COMPILER_MESSAGE_PATTERN.matcher(message);

      if (matcher.matches()) {
        filePath = matcher.group(1);
        line = Integer.parseInt(matcher.group(2));
      }
      final BuildMessage.Kind category = toBuildMessageKind(entry.getKey());
      if (category != null) {
        context.processMessage(
          new CompilerMessage(builderName, category, '[' + entryName + "] " + message, filePath, -1L, -1L, -1L, line, -1L));
      }
    }
  }
}
 

import org.jetbrains.jps.incremental.messages.BuildMessage; //导入依赖的package包/类
@Nullable
public static AndroidPlatform getAndroidPlatform(@NotNull JpsModule module,
                                                 @Nullable CompileContext context,
                                                 String builderName) {
  final JpsSdk<JpsSimpleElement<JpsAndroidSdkProperties>> sdk = module.getSdk(JpsAndroidSdkType.INSTANCE);
  if (sdk == null) {
    if (context != null) {
      context.processMessage(new CompilerMessage(builderName, BuildMessage.Kind.ERROR,
                                                 AndroidJpsBundle.message("android.jps.errors.sdk.not.specified", module.getName())));
    }
    return null;
  }

  final Pair<IAndroidTarget, LocalSdk> pair = getAndroidTarget(sdk, context, builderName);
  if (pair == null) {
    if (context != null) {
      context.processMessage(new CompilerMessage(builderName, BuildMessage.Kind.ERROR,
                                                 AndroidJpsBundle.message("android.jps.errors.sdk.invalid", module.getName())));
    }
    return null;
  }
  return new AndroidPlatform(sdk, pair.getFirst(), pair.getSecond());
}
 

import org.jetbrains.jps.incremental.messages.BuildMessage; //导入依赖的package包/类
private static void warnUserAboutForciblyExcludedRoots(@NotNull Set<String> paths, @NotNull CompileContext context) {
  for (String dir : paths) {
    final boolean hasFileToCopy = !FileUtil.processFilesRecursively(new File(dir), new Processor<File>() {
      @Override
      public boolean process(File file) {
        try {
          return !shouldBeCopied(file);
        }
        catch (IOException e) {
          return false;
        }
      }
    });

    if (hasFileToCopy) {
      context.processMessage(new CompilerMessage(ANDROID_GENERATED_SOURCES_PROCESSOR, BuildMessage.Kind.WARNING,
                                                 "Source root " + FileUtil.toSystemDependentName(dir) +
                                                 " was forcibly excluded by the IDE, so custom generated files won't be compiled"));
    }
  }
}
 

import org.jetbrains.jps.incremental.messages.BuildMessage; //导入依赖的package包/类
private static boolean deleteAndMarkRecursively(@NotNull File dir, @NotNull CompileContext context, @NotNull String compilerName)
  throws IOException {
  if (dir.exists()) {
    final List<File> filesToDelete = collectJavaFilesRecursively(dir);
    if (!FileUtil.delete(dir)) {
      context.processMessage(
        new CompilerMessage(compilerName, BuildMessage.Kind.ERROR, AndroidJpsBundle.message("android.jps.cannot.delete", dir.getPath())));
      return false;
    }

    for (File file : filesToDelete) {
      FSOperations.markDeleted(context, file);
    }
  }
  return true;
}
 

import org.jetbrains.jps.incremental.messages.BuildMessage; //导入依赖的package包/类
private static void addMessages(@NotNull CompileContext context,
                                @NotNull Map<AndroidCompilerMessageKind, List<String>> messages,
                                @NotNull String sourcePath,
                                @NotNull String builderName) {
  for (Map.Entry<AndroidCompilerMessageKind, List<String>> entry : messages.entrySet()) {
    final AndroidCompilerMessageKind kind = entry.getKey();
    final BuildMessage.Kind buildMessageKind = AndroidJpsUtil.toBuildMessageKind(kind);

    if (buildMessageKind == null) {
      continue;
    }

    for (String message : entry.getValue()) {
      context.processMessage(new CompilerMessage(builderName, buildMessageKind, message, sourcePath));
    }
  }
}
 

import org.jetbrains.jps.incremental.messages.BuildMessage; //导入依赖的package包/类
public void copyFile(File file, Ref<File> targetFileRef, ResourceRootConfiguration rootConfiguration, CompileContext context,
                     FileFilter filteringFilter) throws IOException {
  boolean shouldFilter = rootConfiguration.isFiltered && !rootConfiguration.filters.isEmpty() && filteringFilter.accept(file);
  if (shouldFilter && file.length() > FILTERING_SIZE_LIMIT) {
    context.processMessage(new CompilerMessage(
      GradleResourcesBuilder.BUILDER_NAME, BuildMessage.Kind.WARNING,
      "File is too big to be filtered. Most likely it is a binary file and should be excluded from filtering", file.getPath())
    );
    shouldFilter = false;
  }
  if (shouldFilter) {
    copyWithFiltering(file, targetFileRef, rootConfiguration.filters, context);
  }
  else {
    FileUtil.copyContent(file, targetFileRef.get());
  }
}
 

import org.jetbrains.jps.incremental.messages.BuildMessage; //导入依赖的package包/类
public void copyFile(File file, File targetFile, ResourceRootConfiguration rootConfiguration, CompileContext context,
                     FileFilter filteringFilter) throws IOException {
  boolean shouldFilter = rootConfiguration.isFiltered && !myFilteringExcludedExtensions.contains(FileUtilRt.getExtension(file.getName()))
                         && filteringFilter.accept(file);
  if (shouldFilter && file.length() > FILTERING_SIZE_LIMIT) {
    context.processMessage(new CompilerMessage("MavenResources", BuildMessage.Kind.WARNING,
                                               "File is too big to be filtered. Most likely it is a binary file and should be excluded from filtering",
                                               file.getPath()));
    shouldFilter = false;
  }
  if (shouldFilter) {
    copyWithFiltering(file, targetFile);
  }
  else {
    FileUtil.copyContent(file, targetFile);
  }
}
 

import org.jetbrains.jps.incremental.messages.BuildMessage; //导入依赖的package包/类
@Nullable
@Override
protected BinaryContent instrument(CompileContext context, CompiledClass compiled, ClassReader reader, ClassWriter writer, InstrumentationClassFinder finder) {
  final JpsIntelliLangConfiguration config =
    JpsIntelliLangExtensionService.getInstance().getConfiguration(context.getProjectDescriptor().getModel().getGlobal());
  final PatternInstrumenter instrumenter =
    new PatternInstrumenter(config.getPatternAnnotationClass(), writer, config.getInstrumentationType(), finder);
  try {
    reader.accept(instrumenter, 0);
    if (instrumenter.instrumented()) {
      return new BinaryContent(writer.toByteArray());
    }
  }
  catch (InstrumentationException e) {
    context.processMessage(new CompilerMessage(getPresentableName(), BuildMessage.Kind.ERROR, e.getMessage()));
  }
  return null;
}
 

import org.jetbrains.jps.incremental.messages.BuildMessage; //导入依赖的package包/类
public boolean shouldRetry() {
  if (myExitCode != 0) {
    LOG.debug("Non-zero exit code");
    return true;
  }
  for (CompilerMessage message : compilerMessages) {
    if (message.getKind() == BuildMessage.Kind.ERROR) {
      LOG.debug("Error message: " + message);
      return true;
    }
    if (message.getMessageText().contains(GroovyRtConstants.GROOVYC_STUB_GENERATION_FAILED)) {
      LOG.debug("Stub failed message: " + message);
      return true;
    }
  }
  if (getStdErr().length() > 0) {
    LOG.debug("Non-empty stderr: '" + getStdErr() + "'");
    return true;
  }
  return false;
}