java.lang.invoke.WrongMethodTypeException#com.google.devtools.build.lib.syntax.Printer源码实例Demo

@Override
public void debugPrint(Printer printer) {
  // Show the names of the provider keys that this target propagates.
  // Provider key names might potentially be *private* information, and thus a comprehensive
  // list of provider keys should not be exposed in any way other than for debug information.
  printer.append("<target " + getLabel() + ", keys:[");
  ImmutableList.Builder<String> starlarkProviderKeyStrings = ImmutableList.builder();
  for (int providerIndex = 0; providerIndex < providers.getProviderCount(); providerIndex++) {
    Object providerKey = providers.getProviderKeyAt(providerIndex);
    if (providerKey instanceof Provider.Key) {
      starlarkProviderKeyStrings.add(providerKey.toString());
    }
  }
  printer.append(Joiner.on(", ").join(starlarkProviderKeyStrings.build()));
  printer.append("]>");
}
 

@Override
public void debugPrint(Printer printer) {
  printer.append("<LibraryToLink(");
  printer.append(
      Joiner.on(", ")
          .skipNulls()
          .join(
              mapEntry("object", getObjectFiles()),
              mapEntry("pic_objects", getPicObjectFiles()),
              mapEntry("static_library", getStaticLibrary()),
              mapEntry("pic_static_library", getPicStaticLibrary()),
              mapEntry("dynamic_library", getDynamicLibrary()),
              mapEntry("resolved_symlink_dynamic_library", getResolvedSymlinkDynamicLibrary()),
              mapEntry("interface_library", getInterfaceLibrary()),
              mapEntry(
                  "resolved_symlink_interface_library", getResolvedSymlinkInterfaceLibrary()),
              mapEntry("alwayslink", getAlwayslink())));
  printer.append(")>");
}
 

/** Constructor to be used for normal parameters. */
public static FunctionParamInfo forParam(
    String name, String docString, @Nullable Object defaultValue) {
  FunctionParamInfo.Builder paramBuilder =
      FunctionParamInfo.newBuilder().setName(name).setDocString(docString);
  if (defaultValue == null) {
    paramBuilder.setMandatory(true);
  } else {
    BasePrinter printer = Printer.getSimplifiedPrinter();
    printer.repr(defaultValue);
    String defaultValueString = printer.toString();

    if (defaultValueString.isEmpty()) {
      defaultValueString = "{unknown object}";
    }
    paramBuilder.setDefaultValue(defaultValueString).setMandatory(false);
  }
  return paramBuilder.build();
}
 

@Override
public void repr(Printer printer) {
  printer.append("<");
  if (parent() != null) {
    printer.append("parent: ");
    parent().repr(printer);
    printer.append(", ");
  }
  printer.append("[");
  printer.append(
      constraints().values().stream()
          .map(ConstraintValueInfo::label)
          .map(Functions.toStringFunction())
          .collect(joining(", ")));
  printer.append("]");
  printer.append(">");
}
 

@Override
public void repr(Printer printer) {
  printer.append("<toolchain_context.resolved_labels: ");
  printer.append(
      toolchains().keySet().stream()
          .map(ToolchainTypeInfo::typeLabel)
          .map(Label::toString)
          .collect(joining(", ")));
  printer.append(">");
}
 

@Override
public void repr(Printer printer) {
  // Convert to a lib.syntax.SelectorList to guarantee consistency with callers that serialize
  // directly on that type.
  List<SelectorValue> selectorValueList = new ArrayList<>();
  for (Selector<T> element : elements) {
    selectorValueList.add(new SelectorValue(element.getEntries(), element.getNoMatchError()));
  }
  try {
    printer.repr(com.google.devtools.build.lib.packages.SelectorList.of(selectorValueList));
  } catch (EvalException e) {
    throw new IllegalStateException("this list should have been validated on creation");
  }
}
 

@Override
public void debugPrint(Printer printer) {
  printer.append("<CcLinkingContext([");
  for (LinkerInput linkerInput : linkerInputs.toList()) {
    linkerInput.debugPrint(printer);
    printer.append(", ");
  }
  printer.append("])>");
}
 

@Override
public void debugPrint(Printer printer) {
  try {
    printer.append(Joiner.on(" ").join(build().arguments()));
  } catch (CommandLineExpansionException e) {
    printer.append("Cannot expand command line: " + e.getMessage());
  }
}
 

@Override
public void repr(Printer printer) {
  printer.append("SymlinkEntry(path = ");
  printer.repr(getPathString());
  printer.append(", target_file = ");
  getArtifact().repr(printer);
  printer.append(")");
}
 

private static String message(Type<?> type, Object value, @Nullable Object what) {
  Printer.BasePrinter printer = Printer.getPrinter();
  printer.append("expected value of type '").append(type.toString()).append("'");
  if (what != null) {
    printer.append(" for ").append(what.toString());
  }
  printer.append(", but got ");
  printer.repr(value);
  printer.append(" (").append(Starlark.type(value)).append(")");
  return printer.toString();
}
 

@Override
public void repr(Printer printer) {
  if (exportedName == null) {
    printer.append("<anonymous starlark repository rule>");
  } else {
    printer.append("<starlark repository rule " + extensionLabel + "%" + exportedName + ">");
  }
}
 

private static ResolvedEvent resolveBind(Rule rule) {
  String name = rule.getName();
  Label actual = (Label) rule.getAttributeContainer().getAttr("actual");
  String nativeCommand =
      "bind(name = "
          + Printer.getPrinter().repr(name)
          + ", actual = "
          + Printer.getPrinter().repr(actual.getCanonicalForm())
          + ")";

  return new ResolvedEvent() {
    @Override
    public String getName() {
      return name;
    }

    @Override
    public Object getResolvedInformation() {
      return ImmutableMap.<String, Object>builder()
          .put(ResolvedHashesFunction.ORIGINAL_RULE_CLASS, "bind")
          .put(
              ResolvedHashesFunction.ORIGINAL_ATTRIBUTES,
              ImmutableMap.<String, Object>of("name", name, "actual", actual))
          .put(ResolvedHashesFunction.NATIVE, nativeCommand)
          .build();
    }
  };
}
 

@Test
public void repr() {
  SkylarkDependency dep =
      new SkylarkDependency(
          BuildTargetFactory.newInstance("//foo:bar"),
          ProviderInfoCollectionImpl.builder()
              .build(new ImmutableDefaultInfo(SkylarkDict.empty(), ImmutableList.of())));

  assertEquals("<dependency //foo:bar>", Printer.repr(dep));
}
 

@Override
public void repr(Printer printer) {
  printer.format("ConstraintSettingInfo(%s", label.toString());
  if (defaultConstraintValueLabel != null) {
    printer.format(", default_constraint_value=%s", defaultConstraintValueLabel.toString());
  }
  printer.append(")");
}
 

@Override
public void repr(Printer printer) {
  printer.append("depset(");
  printer.printList(set.toList(), "[", ", ", "]", null);
  Order order = getOrder();
  if (order != Order.STABLE_ORDER) {
    printer.append(", order = ");
    printer.repr(order.getStarlarkName());
  }
  printer.append(")");
}
 

@Test
public void testPrintArgs() throws Exception {
  setRuleContext(createRuleContext("//foo:foo"));
  ev.exec("args = ruleContext.actions.args()", "args.add_all(['--foo', '--bar'])");
  Args args = (Args) ev.eval("args");
  assertThat(Printer.getPrinter().debugPrint(args).toString()).isEqualTo("--foo --bar");
}
 

static String representModifications(Map<String, Object> changes) {
  StringBuilder representation = new StringBuilder();
  boolean isFirst = true;
  for (Map.Entry<String, Object> entry : changes.entrySet()) {
    if (!isFirst) {
      representation.append(", ");
    }
    representation
        .append(entry.getKey())
        .append(" = ")
        .append(Printer.getPrinter().repr(entry.getValue()));
    isFirst = false;
  }
  return representation.toString();
}
 

@Override
public void repr(Printer printer) {
  printer.append(path.toString());
}
 

@Override
public void repr(Printer printer) {}
 

@Override
public void repr(Printer printer) {
  printer.append(toString());
}
 

@Override
public void repr(Printer printer) {
  printer.append("<native aspect>");
}
 

@Override
public void repr(Printer printer) {
  printer.printList(elements, "", " + ", "", null);
}
 

@Override
public void repr(Printer printer) {
  printer.format("ToolchainTypeInfo(%s)", typeLabel);
}
 

@Override
public void repr(Printer printer) {
  printer.append("context.args() object");
}
 

@Override
public void repr(Printer printer) {
  printer.append("<output file target " + getLabel() + ">");
}
 

@Override
public void repr(Printer printer) {
  printer.append("<attr>");
}
 

@Override
public void repr(Printer printer) {
  printer.append(toString());
}
 

@Override
public void repr(Printer printer) {
  printer.append(isSourceRoot() ? "<source root>" : "<derived root>");
}
 

@Override
public Map<Label, ValueT> convert(Object x, Object what, Object context)
    throws ConversionException {
  Map<Label, ValueT> result = super.convert(x, what, context);
  // The input is known to be a map because super.convert succeeded; otherwise, a
  // ConversionException would have been thrown.
  Map<?, ?> input = (Map<?, ?>) x;

  if (input.size() == result.size()) {
    // No collisions found. Exit early.
    return result;
  }
  // Look for collisions in order to produce a nicer error message.
  Map<Label, List<Object>> convertedFrom = new LinkedHashMap<>();
  for (Object original : input.keySet()) {
    Label label = LABEL.convert(original, what, context);
    convertedFrom.computeIfAbsent(label, k -> new ArrayList<Object>());
    convertedFrom.get(label).add(original);
  }
  BasePrinter errorMessage = Printer.getPrinter();
  errorMessage.append("duplicate labels");
  if (what != null) {
    errorMessage.append(" in ").append(what.toString());
  }
  errorMessage.append(':');
  boolean isFirstEntry = true;
  for (Map.Entry<Label, List<Object>> entry : convertedFrom.entrySet()) {
    if (entry.getValue().size() == 1) {
      continue;
    }
    if (isFirstEntry) {
      isFirstEntry = false;
    } else {
      errorMessage.append(',');
    }
    errorMessage.append(' ');
    errorMessage.str(entry.getKey());
    errorMessage.append(" (as ");
    errorMessage.repr(entry.getValue());
    errorMessage.append(')');
  }
  throw new ConversionException(errorMessage.toString());
}
 

@Override
public void repr(Printer printer) {
  printer.append("<analysis_test_transition object>");
}