Java Environment.checkLoadingOrWorkspacePhase方法代码示例

import com.google.devtools.build.lib.syntax.Environment; //导入方法依赖的package包/类
public Descriptor invoke(
    Integer defaultInt,
    String doc,
    Boolean mandatory,
    SkylarkList<?> values,
    FuncallExpression ast,
    Environment env)
    throws EvalException {
  // TODO(bazel-team): Replace literal strings with constants.
  env.checkLoadingOrWorkspacePhase("attr.int", ast.getLocation());
  return createAttrDescriptor(
      getName(),
      EvalUtils.<String, Object>optionMap(
          env, DEFAULT_ARG, defaultInt, MANDATORY_ARG, mandatory, VALUES_ARG, values),
      Type.INTEGER,
      ast,
      env);
}
 

import com.google.devtools.build.lib.syntax.Environment; //导入方法依赖的package包/类
public Object invoke(String name, FuncallExpression ast, Environment env)
    throws EvalException, InterruptedException {
  env.checkLoadingOrWorkspacePhase("native.existing_rule", ast.getLocation());
  SkylarkDict<String, Object> rule = PackageFactory.callGetRuleFunction(name, ast, env);
  if (rule != null) {
    return rule;
  }

  return Runtime.NONE;
}
 

import com.google.devtools.build.lib.syntax.Environment; //导入方法依赖的package包/类
@SuppressWarnings({"unchecked", "unused"})
public Runtime.NoneType invoke(
    Map<String, Object> kwargs, FuncallExpression ast, Environment env)
    throws EvalException, InterruptedException {
  env.checkLoadingOrWorkspacePhase(ruleClassName, ast.getLocation());
  try {
    addRule(getContext(env, ast), kwargs, ast, env);
  } catch (RuleFactory.InvalidRuleException | Package.NameConflictException e) {
    throw new EvalException(ast.getLocation(), e.getMessage());
  }
  return Runtime.NONE;
}
 

import com.google.devtools.build.lib.syntax.Environment; //导入方法依赖的package包/类
@SuppressWarnings({"rawtypes", "unchecked"}) // castMap produces
// an Attribute.Builder instead of a Attribute.Builder<?> but it's OK.
public BaseFunction invoke(
    BaseFunction implementation,
    Boolean test,
    Object attrs,
    Object implicitOutputs,
    Boolean executable,
    Boolean outputToGenfiles,
    SkylarkList fragments,
    SkylarkList hostFragments,
    Boolean skylarkTestable,
    SkylarkList<String> toolchains,
    String doc,
    FuncallExpression ast,
    Environment funcallEnv)
    throws EvalException, ConversionException {
  funcallEnv.checkLoadingOrWorkspacePhase("rule", ast.getLocation());
  RuleClassType type = test ? RuleClassType.TEST : RuleClassType.NORMAL;
  RuleClass parent =
      test
          ? getTestBaseRule(SkylarkUtils.getToolsRepository(funcallEnv),
              (PatchTransition) SkylarkUtils.getLipoDataTransition(funcallEnv))
          : (executable ? binaryBaseRule : baseRule);

  // We'll set the name later, pass the empty string for now.
  RuleClass.Builder builder = new RuleClass.Builder("", type, true, parent);
  ImmutableList<Pair<String, SkylarkAttr.Descriptor>> attributes =
      attrObjectToAttributesList(attrs, ast);

  if (skylarkTestable) {
    builder.setSkylarkTestable();
  }

  if (executable || test) {
    addAttribute(
        ast.getLocation(),
        builder,
        attr("$is_executable", BOOLEAN)
            .value(true)
            .nonconfigurable("Called from RunCommand.isExecutable, which takes a Target")
            .build());
    builder.setExecutableSkylark();
  }

  if (implicitOutputs != Runtime.NONE) {
    if (implicitOutputs instanceof BaseFunction) {
      BaseFunction func = (BaseFunction) implicitOutputs;
      SkylarkCallbackFunction callback =
          new SkylarkCallbackFunction(func, ast, funcallEnv.getSemantics());
      builder.setImplicitOutputsFunction(
          new SkylarkImplicitOutputsFunctionWithCallback(callback, ast.getLocation()));
    } else {
      builder.setImplicitOutputsFunction(
          new SkylarkImplicitOutputsFunctionWithMap(
              ImmutableMap.copyOf(
                  castMap(
                      implicitOutputs,
                      String.class,
                      String.class,
                      "implicit outputs of the rule class"))));
    }
  }

  if (outputToGenfiles) {
    builder.setOutputToGenfiles();
  }

  builder.requiresConfigurationFragmentsBySkylarkModuleName(
      fragments.getContents(String.class, "fragments"));
  ConfigAwareRuleClassBuilder.of(builder)
      .requiresHostConfigurationFragmentsBySkylarkModuleName(
          hostFragments.getContents(String.class, "host_fragments"));
  builder.setConfiguredTargetFunction(implementation);
  builder.setRuleDefinitionEnvironment(funcallEnv);
  builder.addRequiredToolchains(collectToolchainLabels(toolchains, ast));

  return new SkylarkRuleFunction(builder, type, attributes, ast.getLocation());
}