diff --git a/src/main/java/com/google/devtools/build/docgen/ApiExporter.java b/src/main/java/com/google/devtools/build/docgen/ApiExporter.java
index 8e1dad6..b04952f 100644
--- a/src/main/java/com/google/devtools/build/docgen/ApiExporter.java
+++ b/src/main/java/com/google/devtools/build/docgen/ApiExporter.java
@@ -27,6 +27,7 @@
 import com.google.devtools.build.lib.skylarkinterface.SkylarkInterfaceUtils;
 import com.google.devtools.build.lib.skylarkinterface.SkylarkModule;
 import com.google.devtools.build.lib.syntax.BaseFunction;
+import com.google.devtools.build.lib.syntax.BuiltinCallable;
 import com.google.devtools.build.lib.syntax.FuncallExpression;
 import com.google.devtools.build.lib.syntax.FunctionSignature;
 import com.google.devtools.build.lib.syntax.MethodDescriptor;
@@ -93,6 +94,15 @@
       Value.Builder value = Value.newBuilder();
       if (obj instanceof BaseFunction) {
         value = collectFunctionInfo((BaseFunction) obj);
+      } else if (obj instanceof BuiltinCallable) {
+        BuiltinCallable builtinCallable = (BuiltinCallable) obj;
+        MethodDescriptor descriptor =
+            builtinCallable.getMethodDescriptor(StarlarkSemantics.DEFAULT_SEMANTICS);
+        value =
+            collectFunctionInfo(
+                descriptor.getName(),
+                SkylarkSignatureProcessor.getSignatureForCallable(
+                    descriptor.getName(), descriptor, null, null));
       } else {
         value.setName(entry.getKey());
       }
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/BuiltinCallable.java b/src/main/java/com/google/devtools/build/lib/syntax/BuiltinCallable.java
index 1b8a6ed..53863be 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/BuiltinCallable.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/BuiltinCallable.java
@@ -42,8 +42,7 @@
       FuncallExpression ast,
       Environment env)
       throws EvalException, InterruptedException {
-    MethodDescriptor methodDescriptor =
-        FuncallExpression.getMethod(env.getSemantics(), obj.getClass(), methodName);
+    MethodDescriptor methodDescriptor = getMethodDescriptor(env.getSemantics());
 
     // TODO(cparsons): Profiling should be done at the MethodDescriptor level.
     try (SilentCloseable c =
@@ -55,6 +54,10 @@
     }
   }
 
+  public MethodDescriptor getMethodDescriptor(StarlarkSemantics semantics) {
+    return FuncallExpression.getMethod(semantics, obj.getClass(), methodName);
+  }
+
   @Override
   public void repr(SkylarkPrinter printer) {
     printer.append("<built-in function " + methodName + ">");
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/FuncallExpression.java b/src/main/java/com/google/devtools/build/lib/syntax/FuncallExpression.java
index 3785595..cc2ae1f 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/FuncallExpression.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/FuncallExpression.java
@@ -660,7 +660,7 @@
         String.format(
             "unexpected keyword%s %s",
             unexpectedKeywords.size() > 1 ? "s" : "",
-            Joiner.on(",").join(Iterables.transform(unexpectedKeywords, s -> "'" + s + "'"))),
+            Joiner.on(", ").join(Iterables.transform(unexpectedKeywords, s -> "'" + s + "'"))),
         method,
         objClass);
   }
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/MethodLibrary.java b/src/main/java/com/google/devtools/build/lib/syntax/MethodLibrary.java
index 9c5787f..b9ff20d 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/MethodLibrary.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/MethodLibrary.java
@@ -27,9 +27,10 @@
 import com.google.devtools.build.lib.events.Event;
 import com.google.devtools.build.lib.events.Location;
 import com.google.devtools.build.lib.skylarkinterface.Param;
+import com.google.devtools.build.lib.skylarkinterface.SkylarkCallable;
+import com.google.devtools.build.lib.skylarkinterface.SkylarkGlobalLibrary;
 import com.google.devtools.build.lib.skylarkinterface.SkylarkModule;
 import com.google.devtools.build.lib.skylarkinterface.SkylarkModuleCategory;
-import com.google.devtools.build.lib.skylarkinterface.SkylarkSignature;
 import com.google.devtools.build.lib.syntax.EvalUtils.ComparisonException;
 import com.google.devtools.build.lib.syntax.SkylarkList.MutableList;
 import com.google.devtools.build.lib.syntax.SkylarkList.Tuple;
@@ -44,13 +45,11 @@
 import javax.annotation.Nullable;
 
 /** A helper class containing built in functions for the Skylark language. */
+@SkylarkGlobalLibrary
 public class MethodLibrary {
 
-  private MethodLibrary() {}
-
-  @SkylarkSignature(
+  @SkylarkCallable(
       name = "min",
-      returnType = Object.class,
       doc =
           "Returns the smallest one of all given arguments. "
               + "If only one argument is provided, it must be a non-empty iterable. "
@@ -61,22 +60,16 @@
           @Param(name = "args", type = SkylarkList.class, doc = "The elements to be checked."),
       useLocation = true,
       useEnvironment = true)
-  private static final BuiltinFunction min =
-      new BuiltinFunction("min") {
-        @SuppressWarnings("unused") // Accessed via Reflection.
-        public Object invoke(SkylarkList<?> args, Location loc, Environment env)
-            throws EvalException {
-          try {
-            return findExtreme(args, EvalUtils.SKYLARK_COMPARATOR.reverse(), loc, env);
-          } catch (ComparisonException e) {
-            throw new EvalException(loc, e);
-          }
-        }
-      };
+  public Object min(SkylarkList<?> args, Location loc, Environment env) throws EvalException {
+    try {
+      return findExtreme(args, EvalUtils.SKYLARK_COMPARATOR.reverse(), loc, env);
+    } catch (ComparisonException e) {
+      throw new EvalException(loc, e);
+    }
+  }
 
-  @SkylarkSignature(
+  @SkylarkCallable(
       name = "max",
-      returnType = Object.class,
       doc =
           "Returns the largest one of all given arguments. "
               + "If only one argument is provided, it must be a non-empty iterable."
@@ -87,18 +80,13 @@
           @Param(name = "args", type = SkylarkList.class, doc = "The elements to be checked."),
       useLocation = true,
       useEnvironment = true)
-  private static final BuiltinFunction max =
-      new BuiltinFunction("max") {
-        @SuppressWarnings("unused") // Accessed via Reflection.
-        public Object invoke(SkylarkList<?> args, Location loc, Environment env)
-            throws EvalException {
-          try {
-            return findExtreme(args, EvalUtils.SKYLARK_COMPARATOR, loc, env);
-          } catch (ComparisonException e) {
-            throw new EvalException(loc, e);
-          }
-        }
-      };
+  public Object max(SkylarkList<?> args, Location loc, Environment env) throws EvalException {
+    try {
+      return findExtreme(args, EvalUtils.SKYLARK_COMPARATOR, loc, env);
+    } catch (ComparisonException e) {
+      throw new EvalException(loc, e);
+    }
+  }
 
   /** Returns the maximum element from this list, as determined by maxOrdering. */
   private static Object findExtreme(
@@ -114,9 +102,8 @@
     }
   }
 
-  @SkylarkSignature(
+  @SkylarkCallable(
       name = "all",
-      returnType = Boolean.class,
       doc =
           "Returns true if all elements evaluate to True or if the collection is empty. "
               + "Elements are converted to boolean using the <a href=\"#bool\">bool</a> function."
@@ -126,22 +113,18 @@
         @Param(
             name = "elements",
             type = Object.class,
-            doc = "A string or a collection of elements.")
+            noneable = true,
+            doc = "A string or a collection of elements.",
+            legacyNamed = true)
       },
       useLocation = true,
       useEnvironment = true)
-  private static final BuiltinFunction all =
-      new BuiltinFunction("all") {
-        @SuppressWarnings("unused") // Accessed via Reflection.
-        public Boolean invoke(Object collection, Location loc, Environment env)
-            throws EvalException {
-          return !hasElementWithBooleanValue(collection, false, loc, env);
-        }
-      };
+  public Boolean all(Object collection, Location loc, Environment env) throws EvalException {
+    return !hasElementWithBooleanValue(collection, false, loc, env);
+  }
 
-  @SkylarkSignature(
+  @SkylarkCallable(
       name = "any",
-      returnType = Boolean.class,
       doc =
           "Returns true if at least one element evaluates to True. "
               + "Elements are converted to boolean using the <a href=\"#bool\">bool</a> function."
@@ -151,18 +134,15 @@
         @Param(
             name = "elements",
             type = Object.class,
-            doc = "A string or a collection of elements.")
+            noneable = true,
+            doc = "A string or a collection of elements.",
+            legacyNamed = true)
       },
       useLocation = true,
       useEnvironment = true)
-  private static final BuiltinFunction any =
-      new BuiltinFunction("any") {
-        @SuppressWarnings("unused") // Accessed via Reflection.
-        public Boolean invoke(Object collection, Location loc, Environment env)
-            throws EvalException {
-          return hasElementWithBooleanValue(collection, true, loc, env);
-        }
-      };
+  public Boolean any(Object collection, Location loc, Environment env) throws EvalException {
+    return hasElementWithBooleanValue(collection, true, loc, env);
+  }
 
   private static boolean hasElementWithBooleanValue(
       Object collection, boolean value, Location loc, Environment env) throws EvalException {
@@ -175,35 +155,29 @@
     return false;
   }
 
-  // supported list methods
-  @SkylarkSignature(
+  @SkylarkCallable(
       name = "sorted",
-      returnType = MutableList.class,
       doc =
           "Sort a collection. Elements should all belong to the same orderable type, they are "
               + "sorted by their value (in ascending order). "
               + "It is an error if elements are not comparable (for example int with string)."
               + "<pre class=\"language-python\">sorted([3, 5, 4]) == [3, 4, 5]</pre>",
-      parameters = {@Param(name = "self", type = Object.class, doc = "This collection.")},
+      parameters = {
+        @Param(name = "self", type = Object.class, doc = "This collection.", legacyNamed = true)
+      },
       useLocation = true,
       useEnvironment = true)
-  private static final BuiltinFunction sorted =
-      new BuiltinFunction("sorted") {
-        public MutableList<?> invoke(Object self, Location loc, Environment env)
-            throws EvalException {
-          try {
-            return MutableList.copyOf(
-                env,
-                EvalUtils.SKYLARK_COMPARATOR.sortedCopy(EvalUtils.toCollection(self, loc, env)));
-          } catch (EvalUtils.ComparisonException e) {
-            throw new EvalException(loc, e);
-          }
-        }
-      };
+  public MutableList<?> sorted(Object self, Location loc, Environment env) throws EvalException {
+    try {
+      return MutableList.copyOf(
+          env, EvalUtils.SKYLARK_COMPARATOR.sortedCopy(EvalUtils.toCollection(self, loc, env)));
+    } catch (EvalUtils.ComparisonException e) {
+      throw new EvalException(loc, e);
+    }
+  }
 
-  @SkylarkSignature(
+  @SkylarkCallable(
       name = "reversed",
-      returnType = MutableList.class,
       doc =
           "Returns a list that contains the elements of the original sequence in reversed order."
               + "<pre class=\"language-python\">reversed([3, 5, 4]) == [4, 5, 3]</pre>",
@@ -211,151 +185,130 @@
         @Param(
             name = "sequence",
             type = Object.class,
-            doc = "The sequence to be reversed (string, list or tuple).")
+            doc = "The sequence to be reversed (string, list or tuple).",
+            legacyNamed = true),
       },
       useLocation = true,
       useEnvironment = true)
-  private static final BuiltinFunction reversed =
-      new BuiltinFunction("reversed") {
-        @SuppressWarnings("unused") // Accessed via Reflection.
-        public MutableList<?> invoke(Object sequence, Location loc, Environment env)
-            throws EvalException {
-          // We only allow lists and strings.
-          if (sequence instanceof SkylarkDict) {
-            throw new EvalException(
-                loc, "Argument to reversed() must be a sequence, not a dictionary.");
-          } else if (sequence instanceof NestedSet || sequence instanceof SkylarkNestedSet) {
-            throw new EvalException(
-                loc, "Argument to reversed() must be a sequence, not a depset.");
-          }
-          ArrayDeque<Object> tmpList = new ArrayDeque<>();
-          for (Object element : EvalUtils.toIterable(sequence, loc, env)) {
-            tmpList.addFirst(element);
-          }
-          return MutableList.copyOf(env, tmpList);
-        }
-      };
+  public MutableList<?> reversed(Object sequence, Location loc, Environment env)
+      throws EvalException {
+    // We only allow lists and strings.
+    if (sequence instanceof SkylarkDict) {
+      throw new EvalException(loc, "Argument to reversed() must be a sequence, not a dictionary.");
+    } else if (sequence instanceof NestedSet || sequence instanceof SkylarkNestedSet) {
+      throw new EvalException(loc, "Argument to reversed() must be a sequence, not a depset.");
+    }
+    ArrayDeque<Object> tmpList = new ArrayDeque<>();
+    for (Object element : EvalUtils.toIterable(sequence, loc, env)) {
+      tmpList.addFirst(element);
+    }
+    return MutableList.copyOf(env, tmpList);
+  }
 
-  @SkylarkSignature(
+  @SkylarkCallable(
       name = "tuple",
-      returnType = Tuple.class,
       doc =
           "Converts a collection (e.g. list, tuple or dictionary) to a tuple."
               + "<pre class=\"language-python\">tuple([1, 2]) == (1, 2)\n"
               + "tuple((2, 3, 2)) == (2, 3, 2)\n"
               + "tuple({5: \"a\", 2: \"b\", 4: \"c\"}) == (5, 2, 4)</pre>",
-      parameters = {@Param(name = "x", doc = "The object to convert.")},
+      parameters = {@Param(name = "x", doc = "The object to convert.", legacyNamed = true)},
       useLocation = true,
       useEnvironment = true)
-  private static final BuiltinFunction tuple =
-      new BuiltinFunction("tuple") {
-        public Tuple<?> invoke(Object x, Location loc, Environment env) throws EvalException {
-          return Tuple.copyOf(EvalUtils.toCollection(x, loc, env));
-        }
-      };
+  public Tuple<?> tuple(Object x, Location loc, Environment env) throws EvalException {
+    return Tuple.copyOf(EvalUtils.toCollection(x, loc, env));
+  }
 
-  @SkylarkSignature(
+  @SkylarkCallable(
       name = "list",
-      returnType = MutableList.class,
       doc =
           "Converts a collection (e.g. list, tuple or dictionary) to a list."
               + "<pre class=\"language-python\">list([1, 2]) == [1, 2]\n"
               + "list((2, 3, 2)) == [2, 3, 2]\n"
               + "list({5: \"a\", 2: \"b\", 4: \"c\"}) == [5, 2, 4]</pre>",
-      parameters = {@Param(name = "x", doc = "The object to convert.")},
+      parameters = {@Param(name = "x", doc = "The object to convert.", legacyNamed = true)},
       useLocation = true,
       useEnvironment = true)
-  private static final BuiltinFunction list =
-      new BuiltinFunction("list") {
-        public MutableList<?> invoke(Object x, Location loc, Environment env) throws EvalException {
-          return MutableList.copyOf(env, EvalUtils.toCollection(x, loc, env));
-        }
-      };
+  public MutableList<?> list(Object x, Location loc, Environment env) throws EvalException {
+    return MutableList.copyOf(env, EvalUtils.toCollection(x, loc, env));
+  }
 
-  @SkylarkSignature(
+  @SkylarkCallable(
       name = "len",
-      returnType = Integer.class,
       doc = "Returns the length of a string, list, tuple, depset, or dictionary.",
-      parameters = {@Param(name = "x", doc = "The object to check length of.")},
+      parameters = {@Param(name = "x", doc = "The object to check length of.", legacyNamed = true)},
       useLocation = true,
       useEnvironment = true)
-  private static final BuiltinFunction len =
-      new BuiltinFunction("len") {
-        public Integer invoke(Object x, Location loc, Environment env) throws EvalException {
-          if (x instanceof String) {
-            return ((String) x).length();
-          } else if (x instanceof Map) {
-            return ((Map<?, ?>) x).size();
-          } else if (x instanceof SkylarkList) {
-            return ((SkylarkList<?>) x).size();
-          } else if (x instanceof SkylarkNestedSet) {
-            if (env.getSemantics().incompatibleDepsetIsNotIterable()) {
-              throw new EvalException(
-                  loc,
-                  EvalUtils.getDataTypeName(x)
-                      + " is not iterable. You may use `len(<depset>.to_list())` instead. Use "
-                      + "--incompatible_depset_is_not_iterable=false to temporarily disable this "
-                      + "check.");
-            }
-            return ((SkylarkNestedSet) x).toCollection().size();
-          } else if (x instanceof Iterable) {
-            // Iterables.size() checks if x is a Collection so it's efficient in that sense.
-            return Iterables.size((Iterable<?>) x);
-          } else {
-            throw new EvalException(loc, EvalUtils.getDataTypeName(x) + " is not iterable");
-          }
-        }
-      };
+  public Integer len(Object x, Location loc, Environment env) throws EvalException {
+    if (x instanceof String) {
+      return ((String) x).length();
+    } else if (x instanceof Map) {
+      return ((Map<?, ?>) x).size();
+    } else if (x instanceof SkylarkList) {
+      return ((SkylarkList<?>) x).size();
+    } else if (x instanceof SkylarkNestedSet) {
+      if (env.getSemantics().incompatibleDepsetIsNotIterable()) {
+        throw new EvalException(
+            loc,
+            EvalUtils.getDataTypeName(x)
+                + " is not iterable. You may use `len(<depset>.to_list())` instead. Use "
+                + "--incompatible_depset_is_not_iterable=false to temporarily disable this "
+                + "check.");
+      }
+      return ((SkylarkNestedSet) x).toCollection().size();
+    } else if (x instanceof Iterable) {
+      // Iterables.size() checks if x is a Collection so it's efficient in that sense.
+      return Iterables.size((Iterable<?>) x);
+    } else {
+      throw new EvalException(loc, EvalUtils.getDataTypeName(x) + " is not iterable");
+    }
+  }
 
-  @SkylarkSignature(
+  @SkylarkCallable(
       name = "str",
-      returnType = String.class,
       doc =
           "Converts any object to string. This is useful for debugging."
               + "<pre class=\"language-python\">str(\"ab\") == \"ab\"\n"
               + "str(8) == \"8\"</pre>",
-      parameters = {@Param(name = "x", doc = "The object to convert.")})
-  private static final BuiltinFunction str =
-      new BuiltinFunction("str") {
-        public String invoke(Object x) {
-          return Printer.str(x);
-        }
-      };
+      parameters = {
+        @Param(name = "x", doc = "The object to convert.", legacyNamed = true, noneable = true)
+      })
+  public String str(Object x) {
+    return Printer.str(x);
+  }
 
-  @SkylarkSignature(
+  @SkylarkCallable(
       name = "repr",
-      returnType = String.class,
       doc =
           "Converts any object to a string representation. This is useful for debugging.<br>"
               + "<pre class=\"language-python\">repr(\"ab\") == '\"ab\"'</pre>",
-      parameters = {@Param(name = "x", doc = "The object to convert.")})
-  private static final BuiltinFunction repr =
-      new BuiltinFunction("repr") {
-        public String invoke(Object x) {
-          return Printer.repr(x);
-        }
-      };
+      parameters = {
+        @Param(name = "x", doc = "The object to convert.", legacyNamed = true, noneable = true)
+      })
+  public String repr(Object x) {
+    return Printer.repr(x);
+  }
 
-  @SkylarkSignature(
+  @SkylarkCallable(
       name = "bool",
-      returnType = Boolean.class,
       doc =
           "Constructor for the bool type. "
               + "It returns <code>False</code> if the object is <code>None</code>, <code>False"
               + "</code>, an empty string (<code>\"\"</code>), the number <code>0</code>, or an "
               + "empty collection (e.g. <code>()</code>, <code>[]</code>). "
               + "Otherwise, it returns <code>True</code>.",
-      parameters = {@Param(name = "x", doc = "The variable to convert.")})
-  private static final BuiltinFunction bool =
-      new BuiltinFunction("bool") {
-        public Boolean invoke(Object x) throws EvalException {
-          return EvalUtils.toBoolean(x);
-        }
-      };
+      parameters = {
+        @Param(name = "x", doc = "The variable to convert.", legacyNamed = true, noneable = true)
+      })
+  public Boolean bool(Object x) throws EvalException {
+    return EvalUtils.toBoolean(x);
+  }
 
-  @SkylarkSignature(
+  private final ImmutableMap<String, Integer> intPrefixes =
+      ImmutableMap.of("0b", 2, "0o", 8, "0x", 16);
+
+  @SkylarkCallable(
       name = "int",
-      returnType = Integer.class,
       doc =
           "Returns x as an int value."
               + "<ul>"
@@ -394,7 +347,7 @@
               + "int(\"-0x10\", 0) == -16"
               + "</pre>",
       parameters = {
-        @Param(name = "x", type = Object.class, doc = "The string to convert."),
+        @Param(name = "x", type = Object.class, doc = "The string to convert.", legacyNamed = true),
         @Param(
             name = "base",
             type = Object.class,
@@ -403,117 +356,106 @@
                 "The base used to interpret a string value; defaults to 10. Must be between 2 "
                     + "and 36 (inclusive), or 0 to detect the base as if <code>x</code> were an "
                     + "integer literal. This parameter must not be supplied if the value is not a "
-                    + "string.")
+                    + "string.",
+            legacyNamed = true)
       },
       useLocation = true)
-  private static final BuiltinFunction int_ =
-      new BuiltinFunction("int") {
-        private final ImmutableMap<String, Integer> intPrefixes =
-            ImmutableMap.of("0b", 2, "0o", 8, "0x", 16);
+  public Integer convertToInt(Object x, Object base, Location loc) throws EvalException {
+    if (x instanceof String) {
+      if (base == Runtime.UNBOUND) {
+        base = 10;
+      } else if (!(base instanceof Integer)) {
+        throw new EvalException(
+            loc, "base must be an integer (got '" + EvalUtils.getDataTypeName(base) + "')");
+      }
+      return fromString((String) x, loc, (Integer) base);
+    } else {
+      if (base != Runtime.UNBOUND) {
+        throw new EvalException(loc, "int() can't convert non-string with explicit base");
+      }
+      if (x instanceof Boolean) {
+        return ((Boolean) x).booleanValue() ? 1 : 0;
+      } else if (x instanceof Integer) {
+        return (Integer) x;
+      }
+      throw new EvalException(loc, Printer.format("%r is not of type string or int or bool", x));
+    }
+  }
 
-        @SuppressWarnings("unused")
-        public Integer invoke(Object x, Object base, Location loc) throws EvalException {
-          if (x instanceof String) {
-            if (base == Runtime.UNBOUND) {
-              base = 10;
-            } else if (!(base instanceof Integer)) {
-              throw new EvalException(
-                  loc, "base must be an integer (got '" + EvalUtils.getDataTypeName(base) + "')");
-            }
-            return fromString((String) x, loc, (Integer) base);
-          } else {
-            if (base != Runtime.UNBOUND) {
-              throw new EvalException(loc, "int() can't convert non-string with explicit base");
-            }
-            if (x instanceof Boolean) {
-              return ((Boolean) x).booleanValue() ? 1 : 0;
-            } else if (x instanceof Integer) {
-              return (Integer) x;
-            }
-            throw new EvalException(
-                loc, Printer.format("%r is not of type string or int or bool", x));
-          }
+  private int fromString(String string, Location loc, int base) throws EvalException {
+    String stringForErrors = string;
+
+    boolean isNegative = false;
+    if (string.isEmpty()) {
+      throw new EvalException(loc, Printer.format("string argument to int() cannot be empty"));
+    }
+    char c = string.charAt(0);
+    if (c == '+') {
+      string = string.substring(1);
+    } else if (c == '-') {
+      string = string.substring(1);
+      isNegative = true;
+    }
+
+    String prefix = getIntegerPrefix(string);
+    String digits;
+    if (prefix == null) {
+      // Nothing to strip. Infer base 10 if autodetection was requested (base == 0).
+      digits = string;
+      if (base == 0) {
+        if (string.length() > 1 && string.startsWith("0")) {
+          // We don't infer the base when input starts with '0' (due
+          // to confusion between octal and decimal).
+          throw new EvalException(
+              loc,
+              Printer.format(
+                  "cannot infer base for int() when value begins with a 0: %r", stringForErrors));
         }
+        base = 10;
+      }
+    } else {
+      // Strip prefix. Infer base from prefix if unknown (base == 0), or else verify its
+      // consistency.
+      digits = string.substring(prefix.length());
+      int expectedBase = intPrefixes.get(prefix);
+      if (base == 0) {
+        base = expectedBase;
+      } else if (base != expectedBase) {
+        throw new EvalException(
+            loc,
+            Printer.format("invalid literal for int() with base %d: %r", base, stringForErrors));
+      }
+    }
 
-        private int fromString(String string, Location loc, int base) throws EvalException {
-          String stringForErrors = string;
+    if (base < 2 || base > 36) {
+      throw new EvalException(loc, "int() base must be >= 2 and <= 36");
+    }
+    try {
+      // Negate by prepending a negative symbol, rather than by using arithmetic on the
+      // result, to handle the edge case of -2^31 correctly.
+      String parseable = isNegative ? "-" + digits : digits;
+      return Integer.parseInt(parseable, base);
+    } catch (NumberFormatException | ArithmeticException e) {
+      throw new EvalException(
+          loc,
+          Printer.format("invalid literal for int() with base %d: %r", base, stringForErrors),
+          e);
+    }
+  }
 
-          boolean isNegative = false;
-          if (string.isEmpty()) {
-            throw new EvalException(
-                loc, Printer.format("string argument to int() cannot be empty"));
-          }
-          char c = string.charAt(0);
-          if (c == '+') {
-            string = string.substring(1);
-          } else if (c == '-') {
-            string = string.substring(1);
-            isNegative = true;
-          }
+  @Nullable
+  private String getIntegerPrefix(String value) {
+    value = Ascii.toLowerCase(value);
+    for (String prefix : intPrefixes.keySet()) {
+      if (value.startsWith(prefix)) {
+        return prefix;
+      }
+    }
+    return null;
+  }
 
-          String prefix = getIntegerPrefix(string);
-          String digits;
-          if (prefix == null) {
-            // Nothing to strip. Infer base 10 if autodetection was requested (base == 0).
-            digits = string;
-            if (base == 0) {
-              if (string.length() > 1 && string.startsWith("0")) {
-                // We don't infer the base when input starts with '0' (due
-                // to confusion between octal and decimal).
-                throw new EvalException(
-                    loc,
-                    Printer.format(
-                        "cannot infer base for int() when value begins with a 0: %r",
-                        stringForErrors));
-              }
-              base = 10;
-            }
-          } else {
-            // Strip prefix. Infer base from prefix if unknown (base == 0), or else verify its
-            // consistency.
-            digits = string.substring(prefix.length());
-            int expectedBase = intPrefixes.get(prefix);
-            if (base == 0) {
-              base = expectedBase;
-            } else if (base != expectedBase) {
-              throw new EvalException(
-                  loc,
-                  Printer.format(
-                      "invalid literal for int() with base %d: %r", base, stringForErrors));
-            }
-          }
-
-          if (base < 2 || base > 36) {
-            throw new EvalException(loc, "int() base must be >= 2 and <= 36");
-          }
-          try {
-            // Negate by prepending a negative symbol, rather than by using arithmetic on the
-            // result, to handle the edge case of -2^31 correctly.
-            String parseable = isNegative ? "-" + digits : digits;
-            return Integer.parseInt(parseable, base);
-          } catch (NumberFormatException | ArithmeticException e) {
-            throw new EvalException(
-                loc,
-                Printer.format("invalid literal for int() with base %d: %r", base, stringForErrors),
-                e);
-          }
-        }
-
-        @Nullable
-        private String getIntegerPrefix(String value) {
-          value = Ascii.toLowerCase(value);
-          for (String prefix : intPrefixes.keySet()) {
-            if (value.startsWith(prefix)) {
-              return prefix;
-            }
-          }
-          return null;
-        }
-      };
-
-  @SkylarkSignature(
+  @SkylarkCallable(
       name = "dict",
-      returnType = SkylarkDict.class,
       doc =
           "Creates a <a href=\"dict.html\">dictionary</a> from an optional positional "
               + "argument and an optional set of keyword arguments. In the case where the same key "
@@ -527,49 +469,43 @@
             defaultValue = "[]",
             doc =
                 "Either a dictionary or a list of entries. Entries must be tuples or lists with "
-                    + "exactly two elements: key, value."),
+                    + "exactly two elements: key, value.",
+            legacyNamed = true),
       },
       extraKeywords = @Param(name = "kwargs", doc = "Dictionary of additional entries."),
       useLocation = true,
       useEnvironment = true)
-  private static final BuiltinFunction dict =
-      new BuiltinFunction("dict") {
-        public SkylarkDict<?, ?> invoke(
-            Object args, SkylarkDict<String, Object> kwargs, Location loc, Environment env)
-            throws EvalException {
-          SkylarkDict<?, ?> argsDict =
-              (args instanceof SkylarkDict)
-                  ? (SkylarkDict<?, ?>) args
-                  : SkylarkDict.getDictFromArgs(args, loc, env);
-          return SkylarkDict.plus(argsDict, kwargs, env);
-        }
-      };
+  public SkylarkDict<?, ?> dict(
+      Object args, SkylarkDict<?, ?> kwargs, Location loc, Environment env) throws EvalException {
+    SkylarkDict<?, ?> argsDict =
+        (args instanceof SkylarkDict)
+            ? (SkylarkDict<?, ?>) args
+            : SkylarkDict.getDictFromArgs(args, loc, env);
+    return SkylarkDict.plus(argsDict, kwargs, env);
+  }
 
-  @SkylarkSignature(
+  @SkylarkCallable(
       name = "enumerate",
-      returnType = MutableList.class,
       doc =
           "Returns a list of pairs (two-element tuples), with the index (int) and the item from"
               + " the input list.\n<pre class=\"language-python\">"
               + "enumerate([24, 21, 84]) == [(0, 24), (1, 21), (2, 84)]</pre>\n",
-      parameters = {@Param(name = "list", type = SkylarkList.class, doc = "input list.")},
+      parameters = {
+        @Param(name = "list", type = SkylarkList.class, doc = "input list.", legacyNamed = true)
+      },
       useEnvironment = true)
-  private static final BuiltinFunction enumerate =
-      new BuiltinFunction("enumerate") {
-        public MutableList<?> invoke(SkylarkList<?> input, Environment env) throws EvalException {
-          int count = 0;
-          ArrayList<SkylarkList<?>> result = new ArrayList<>(input.size());
-          for (Object obj : input) {
-            result.add(Tuple.of(count, obj));
-            count++;
-          }
-          return MutableList.wrapUnsafe(env, result);
-        }
-      };
+  public MutableList<?> enumerate(SkylarkList<?> input, Environment env) throws EvalException {
+    int count = 0;
+    ArrayList<SkylarkList<?>> result = new ArrayList<>(input.size());
+    for (Object obj : input) {
+      result.add(Tuple.of(count, obj));
+      count++;
+    }
+    return MutableList.wrapUnsafe(env, result);
+  }
 
-  @SkylarkSignature(
+  @SkylarkCallable(
       name = "hash",
-      returnType = Integer.class,
       doc =
           "Return a hash value for a string. This is computed deterministically using the same "
               + "algorithm as Java's <code>String.hashCode()</code>, namely: "
@@ -578,17 +514,19 @@
       // Deterministic hashing is important for the consistency of builds, hence why we
       // promise a specific algorithm. This is in contrast to Java (Object.hashCode()) and
       // Python, which promise stable hashing only within a given execution of the program.
-      parameters = {@Param(name = "value", type = String.class, doc = "String value to hash.")})
-  private static final BuiltinFunction hash =
-      new BuiltinFunction("hash") {
-        public Integer invoke(String value) throws EvalException {
-          return value.hashCode();
-        }
-      };
+      parameters = {
+        @Param(
+            name = "value",
+            type = String.class,
+            doc = "String value to hash.",
+            legacyNamed = true)
+      })
+  public Integer hash(String value) throws EvalException {
+    return value.hashCode();
+  }
 
-  @SkylarkSignature(
+  @SkylarkCallable(
       name = "range",
-      returnType = SkylarkList.class,
       doc =
           "Creates a list where items go from <code>start</code> to <code>stop</code>, using a "
               + "<code>step</code> increment. If a single argument is provided, items will "
@@ -602,7 +540,8 @@
             type = Integer.class,
             doc =
                 "Value of the start element if stop is provided, "
-                    + "otherwise value of stop and the actual start is 0"),
+                    + "otherwise value of stop and the actual start is 0",
+            legacyNamed = true),
         @Param(
             name = "stop_or_none",
             type = Integer.class,
@@ -610,62 +549,60 @@
             defaultValue = "None",
             doc =
                 "optional index of the first item <i>not</i> to be included in the resulting "
-                    + "list; generation of the list stops before <code>stop</code> is reached."),
+                    + "list; generation of the list stops before <code>stop</code> is reached.",
+            legacyNamed = true),
         @Param(
             name = "step",
             type = Integer.class,
             defaultValue = "1",
-            doc = "The increment (default is 1). It may be negative.")
+            doc = "The increment (default is 1). It may be negative.",
+            legacyNamed = true)
       },
       useLocation = true,
       useEnvironment = true)
-  private static final BuiltinFunction range =
-      new BuiltinFunction("range") {
-        public SkylarkList<Integer> invoke(
-            Integer startOrStop, Object stopOrNone, Integer step, Location loc, Environment env)
-            throws EvalException {
-          int start;
-          int stop;
-          if (stopOrNone == Runtime.NONE) {
-            start = 0;
-            stop = startOrStop;
-          } else {
-            start = startOrStop;
-            stop = Type.INTEGER.convert(stopOrNone, "'stop' operand of 'range'");
-          }
-          if (step == 0) {
-            throw new EvalException(loc, "step cannot be 0");
-          }
-          return RangeList.of(start, stop, step);
-        }
-      };
+  public SkylarkList<Integer> range(
+      Integer startOrStop, Object stopOrNone, Integer step, Location loc, Environment env)
+      throws EvalException {
+    int start;
+    int stop;
+    if (stopOrNone == Runtime.NONE) {
+      start = 0;
+      stop = startOrStop;
+    } else {
+      start = startOrStop;
+      stop = Type.INTEGER.convert(stopOrNone, "'stop' operand of 'range'");
+    }
+    if (step == 0) {
+      throw new EvalException(loc, "step cannot be 0");
+    }
+    return RangeList.of(start, stop, step);
+  }
 
   /** Returns true if the object has a field of the given name, otherwise false. */
-  @SkylarkSignature(
+  @SkylarkCallable(
       name = "hasattr",
-      returnType = Boolean.class,
       doc =
           "Returns True if the object <code>x</code> has an attribute or method of the given "
               + "<code>name</code>, otherwise False. Example:<br>"
               + "<pre class=\"language-python\">hasattr(ctx.attr, \"myattr\")</pre>",
       parameters = {
-        @Param(name = "x", doc = "The object to check."),
-        @Param(name = "name", type = String.class, doc = "The name of the attribute.")
+        @Param(name = "x", doc = "The object to check.", legacyNamed = true, noneable = true),
+        @Param(
+            name = "name",
+            type = String.class,
+            doc = "The name of the attribute.",
+            legacyNamed = true)
       },
       useEnvironment = true)
-  private static final BuiltinFunction hasattr =
-      new BuiltinFunction("hasattr") {
-        @SuppressWarnings("unused")
-        public Boolean invoke(Object obj, String name, Environment env) throws EvalException {
-          if (obj instanceof ClassObject && ((ClassObject) obj).getValue(name) != null) {
-            return true;
-          }
-          // shouldn't this filter things with struct_field = false?
-          return DotExpression.hasMethod(env.getSemantics(), obj, name);
-        }
-      };
+  public Boolean hasAttr(Object obj, String name, Environment env) throws EvalException {
+    if (obj instanceof ClassObject && ((ClassObject) obj).getValue(name) != null) {
+      return true;
+    }
+    // shouldn't this filter things with struct_field = false?
+    return DotExpression.hasMethod(env.getSemantics(), obj, name);
+  }
 
-  @SkylarkSignature(
+  @SkylarkCallable(
       name = "getattr",
       doc =
           "Returns the struct's field of the given name if it exists. If not, it either returns "
@@ -676,70 +613,69 @@
               + "<pre class=\"language-python\">getattr(ctx.attr, \"myattr\")\n"
               + "getattr(ctx.attr, \"myattr\", \"mydefault\")</pre>",
       parameters = {
-        @Param(name = "x", doc = "The struct whose attribute is accessed."),
-        @Param(name = "name", doc = "The name of the struct attribute."),
+        @Param(
+            name = "x",
+            doc = "The struct whose attribute is accessed.",
+            legacyNamed = true,
+            noneable = true),
+        @Param(name = "name", doc = "The name of the struct attribute.", legacyNamed = true),
         @Param(
             name = "default",
             defaultValue = "unbound",
             doc =
                 "The default value to return in case the struct "
-                    + "doesn't have an attribute of the given name.")
+                    + "doesn't have an attribute of the given name.",
+            legacyNamed = true,
+            noneable = true)
       },
       useLocation = true,
       useEnvironment = true)
-  private static final BuiltinFunction getattr =
-      new BuiltinFunction("getattr") {
-        @SuppressWarnings("unused")
-        public Object invoke(
-            Object obj, String name, Object defaultValue, Location loc, Environment env)
-            throws EvalException, InterruptedException {
-          Object result = DotExpression.eval(obj, name, loc, env);
-          if (result == null) {
-            if (defaultValue != Runtime.UNBOUND) {
-              return defaultValue;
-            }
-            throw DotExpression.getMissingFieldException(
-                obj, name, loc, env.getSemantics(), "attribute");
-          }
-          return result;
-        }
-      };
+  public Object getAttr(Object obj, String name, Object defaultValue, Location loc, Environment env)
+      throws EvalException, InterruptedException {
+    Object result = DotExpression.eval(obj, name, loc, env);
+    if (result == null) {
+      if (defaultValue != Runtime.UNBOUND) {
+        return defaultValue;
+      }
+      throw DotExpression.getMissingFieldException(obj, name, loc, env.getSemantics(), "attribute");
+    }
+    return result;
+  }
 
-  @SkylarkSignature(
+  @SkylarkCallable(
       name = "dir",
-      returnType = MutableList.class,
       doc =
           "Returns a list of strings: the names of the attributes and "
               + "methods of the parameter object.",
-      parameters = {@Param(name = "x", doc = "The object to check.")},
+      parameters = {
+        @Param(name = "x", doc = "The object to check.", legacyNamed = true, noneable = true)
+      },
       useLocation = true,
       useEnvironment = true)
-  private static final BuiltinFunction dir =
-      new BuiltinFunction("dir") {
-        public MutableList<?> invoke(Object object, Location loc, Environment env)
-            throws EvalException {
-          // Order the fields alphabetically.
-          Set<String> fields = new TreeSet<>();
-          if (object instanceof ClassObject) {
-            fields.addAll(((ClassObject) object).getFieldNames());
-          }
-          fields.addAll(Runtime.getBuiltinRegistry().getFunctionNames(object.getClass()));
-          fields.addAll(FuncallExpression.getMethodNames(env.getSemantics(), object.getClass()));
-          return MutableList.copyOf(env, fields);
-        }
-      };
+  public MutableList<?> dir(Object object, Location loc, Environment env) throws EvalException {
+    // Order the fields alphabetically.
+    Set<String> fields = new TreeSet<>();
+    if (object instanceof ClassObject) {
+      fields.addAll(((ClassObject) object).getFieldNames());
+    }
+    fields.addAll(Runtime.getBuiltinRegistry().getFunctionNames(object.getClass()));
+    fields.addAll(FuncallExpression.getMethodNames(env.getSemantics(), object.getClass()));
+    return MutableList.copyOf(env, fields);
+  }
 
-  @SkylarkSignature(
+  @SkylarkCallable(
       name = "fail",
       doc =
           "Raises an error that cannot be intercepted. It can be used anywhere, "
               + "both in the loading phase and in the analysis phase.",
-      returnType = Runtime.NoneType.class,
       parameters = {
         @Param(
             name = "msg",
             type = Object.class,
-            doc = "Error to display for the user. The object is converted to a string."),
+            doc = "Error to display for the user. The object is converted to a string.",
+            defaultValue = "None",
+            legacyNamed = true,
+            noneable = true),
         @Param(
             name = "attr",
             type = String.class,
@@ -747,23 +683,20 @@
             defaultValue = "None",
             doc =
                 "The name of the attribute that caused the error. This is used only for "
-                    + "error reporting.")
+                    + "error reporting.",
+            legacyNamed = true)
       },
       useLocation = true)
-  private static final BuiltinFunction fail =
-      new BuiltinFunction("fail") {
-        public Runtime.NoneType invoke(Object msg, Object attr, Location loc) throws EvalException {
-          String str = Printer.str(msg);
-          if (attr != Runtime.NONE) {
-            str = String.format("attribute %s: %s", attr, str);
-          }
-          throw new EvalException(loc, str);
-        }
-      };
+  public Runtime.NoneType fail(Object msg, Object attr, Location loc) throws EvalException {
+    String str = Printer.str(msg);
+    if (attr != Runtime.NONE) {
+      str = String.format("attribute %s: %s", attr, str);
+    }
+    throw new EvalException(loc, str);
+  }
 
-  @SkylarkSignature(
+  @SkylarkCallable(
       name = "print",
-      returnType = Runtime.NoneType.class,
       doc =
           "Prints <code>args</code> as debug output. It will be prefixed with the string <code>"
               + "\"DEBUG\"</code> and the location (file and line number) of this call. The "
@@ -787,26 +720,21 @@
       extraPositionals = @Param(name = "args", doc = "The objects to print."),
       useLocation = true,
       useEnvironment = true)
-  private static final BuiltinFunction print =
-      new BuiltinFunction("print") {
-        public Runtime.NoneType invoke(
-            String sep, SkylarkList<?> starargs, Location loc, Environment env)
-            throws EvalException {
-          String msg = starargs.stream().map(Printer::debugPrint).collect(joining(sep));
-          // As part of the integration test "skylark_flag_test.sh", if the
-          // "--internal_skylark_flag_test_canary" flag is enabled, append an extra marker string to
-          // the output.
-          if (env.getSemantics().internalSkylarkFlagTestCanary()) {
-            msg += "<== skylark flag test ==>";
-          }
-          env.handleEvent(Event.debug(loc, msg));
-          return Runtime.NONE;
-        }
-      };
+  public Runtime.NoneType print(String sep, SkylarkList<?> starargs, Location loc, Environment env)
+      throws EvalException {
+    String msg = starargs.stream().map(Printer::debugPrint).collect(joining(sep));
+    // As part of the integration test "skylark_flag_test.sh", if the
+    // "--internal_skylark_flag_test_canary" flag is enabled, append an extra marker string to
+    // the output.
+    if (env.getSemantics().internalSkylarkFlagTestCanary()) {
+      msg += "<== skylark flag test ==>";
+    }
+    env.handleEvent(Event.debug(loc, msg));
+    return Runtime.NONE;
+  }
 
-  @SkylarkSignature(
+  @SkylarkCallable(
       name = "type",
-      returnType = String.class,
       doc =
           "Returns the type name of its argument. This is useful for debugging and "
               + "type-checking. Examples:"
@@ -820,18 +748,20 @@
               + "<pre class=\"language-python\">"
               + "if type(x) == type([]):  # if x is a list"
               + "</pre>",
-      parameters = {@Param(name = "x", doc = "The object to check type of.")})
-  private static final BuiltinFunction type =
-      new BuiltinFunction("type") {
-        public String invoke(Object object) {
-          // There is no 'type' type in Skylark, so we return a string with the type name.
-          return EvalUtils.getDataTypeName(object, false);
-        }
-      };
+      parameters = {
+        @Param(
+            name = "x",
+            doc = "The object to check type of.",
+            legacyNamed = true,
+            noneable = true)
+      })
+  public String type(Object object) {
+    // There is no 'type' type in Skylark, so we return a string with the type name.
+    return EvalUtils.getDataTypeName(object, false);
+  }
 
-  @SkylarkSignature(
+  @SkylarkCallable(
       name = "depset",
-      returnType = SkylarkNestedSet.class,
       doc =
           "Creates a <a href=\"depset.html\">depset</a>. The <code>direct</code> parameter is a "
               + "list of direct elements of the depset, and <code>transitive</code> parameter is "
@@ -861,14 +791,16 @@
                 "Deprecated: Either an iterable whose items become the direct elements of "
                     + "the new depset, in left-to-right order, or else a depset that becomes "
                     + "a transitive element of the new depset. In the latter case, "
-                    + "<code>transitive</code> cannot be specified."),
+                    + "<code>transitive</code> cannot be specified.",
+            legacyNamed = true),
         @Param(
             name = "order",
             type = String.class,
             defaultValue = "\"default\"",
             doc =
                 "The traversal strategy for the new depset. See "
-                    + "<a href=\"depset.html\">here</a> for the possible values."),
+                    + "<a href=\"depset.html\">here</a> for the possible values.",
+            legacyNamed = true),
         @Param(
             name = "direct",
             type = SkylarkList.class,
@@ -888,55 +820,52 @@
             defaultValue = "None")
       },
       useLocation = true)
-  private static final BuiltinFunction depset =
-      new BuiltinFunction("depset") {
-        public SkylarkNestedSet invoke(
-            Object items, String orderString, Object direct, Object transitive, Location loc)
-            throws EvalException {
-          Order order;
-          try {
-            order = Order.parse(orderString);
-          } catch (IllegalArgumentException ex) {
-            throw new EvalException(loc, ex);
-          }
+  public SkylarkNestedSet depset(
+      Object items, String orderString, Object direct, Object transitive, Location loc)
+      throws EvalException {
+    Order order;
+    try {
+      order = Order.parse(orderString);
+    } catch (IllegalArgumentException ex) {
+      throw new EvalException(loc, ex);
+    }
 
-          if (transitive == Runtime.NONE && direct == Runtime.NONE) {
-            // Legacy behavior.
-            return SkylarkNestedSet.of(order, items, loc);
-          }
+    if (transitive == Runtime.NONE && direct == Runtime.NONE) {
+      // Legacy behavior.
+      return SkylarkNestedSet.of(order, items, loc);
+    }
 
-          if (direct != Runtime.NONE && !isEmptySkylarkList(items)) {
-            throw new EvalException(
-                loc, "Do not pass both 'direct' and 'items' argument to depset constructor.");
-          }
+    if (direct != Runtime.NONE && !isEmptySkylarkList(items)) {
+      throw new EvalException(
+          loc, "Do not pass both 'direct' and 'items' argument to depset constructor.");
+    }
 
-          // Non-legacy behavior: either 'transitive' or 'direct' were specified.
-          Iterable<Object> directElements;
-          if (direct != Runtime.NONE) {
-            directElements = ((SkylarkList<?>) direct).getContents(Object.class, "direct");
-          } else {
-            SkylarkType.checkType(items, SkylarkList.class, "items");
-            directElements = ((SkylarkList<?>) items).getContents(Object.class, "items");
-          }
+    // Non-legacy behavior: either 'transitive' or 'direct' were specified.
+    Iterable<Object> directElements;
+    if (direct != Runtime.NONE) {
+      directElements = ((SkylarkList<?>) direct).getContents(Object.class, "direct");
+    } else {
+      SkylarkType.checkType(items, SkylarkList.class, "items");
+      directElements = ((SkylarkList<?>) items).getContents(Object.class, "items");
+    }
 
-          Iterable<SkylarkNestedSet> transitiveList;
-          if (transitive != Runtime.NONE) {
-            SkylarkType.checkType(transitive, SkylarkList.class, "transitive");
-            transitiveList =
-                ((SkylarkList<?>) transitive).getContents(SkylarkNestedSet.class, "transitive");
-          } else {
-            transitiveList = ImmutableList.of();
-          }
-          SkylarkNestedSet.Builder builder = SkylarkNestedSet.builder(order, loc);
-          for (Object directElement : directElements) {
-            builder.addDirect(directElement);
-          }
-          for (SkylarkNestedSet transitiveSet : transitiveList) {
-            builder.addTransitive(transitiveSet);
-          }
-          return builder.build();
-        }
-      };
+    Iterable<SkylarkNestedSet> transitiveList;
+    if (transitive != Runtime.NONE) {
+      SkylarkType.checkType(transitive, SkylarkList.class, "transitive");
+      transitiveList =
+          ((SkylarkList<?>) transitive).getContents(SkylarkNestedSet.class, "transitive");
+    } else {
+      transitiveList = ImmutableList.of();
+    }
+    SkylarkNestedSet.Builder builder = SkylarkNestedSet.builder(order, loc);
+    for (Object directElement : directElements) {
+      builder.addDirect(directElement);
+    }
+    for (SkylarkNestedSet transitiveSet : transitiveList) {
+      builder.addTransitive(transitiveSet);
+    }
+    return builder.build();
+  }
 
   private static boolean isEmptySkylarkList(Object o) {
     return o instanceof SkylarkList && ((SkylarkList) o).isEmpty();
@@ -946,7 +875,7 @@
    * Returns a function-value implementing "select" (i.e. configurable attributes) in the specified
    * package context.
    */
-  @SkylarkSignature(
+  @SkylarkCallable(
       name = "select",
       doc =
           "<code>select()</code> is the helper function that makes a rule attribute "
@@ -954,29 +883,31 @@
               + "configurable</a>. See "
               + "<a href=\"$BE_ROOT/functions.html#select\">build encyclopedia</a> for details.",
       parameters = {
-        @Param(name = "x", type = SkylarkDict.class, doc = "The parameter to convert."),
+        @Param(
+            name = "x",
+            type = SkylarkDict.class,
+            doc = "The parameter to convert.",
+            legacyNamed = true),
         @Param(
             name = "no_match_error",
             type = String.class,
             defaultValue = "''",
-            doc = "Optional custom error to report if no condition matches.")
+            doc = "Optional custom error to report if no condition matches.",
+            legacyNamed = true)
       },
       useLocation = true)
-  private static final BuiltinFunction select =
-      new BuiltinFunction("select") {
-        public Object invoke(SkylarkDict<?, ?> dict, String noMatchError, Location loc)
-            throws EvalException {
-          for (Object key : dict.keySet()) {
-            if (!(key instanceof String)) {
-              throw new EvalException(
-                  loc, String.format("Invalid key: %s. select keys must be label references", key));
-            }
-          }
-          return SelectorList.of(new SelectorValue(dict, noMatchError));
-        }
-      };
+  public Object select(SkylarkDict<?, ?> dict, String noMatchError, Location loc)
+      throws EvalException {
+    for (Object key : dict.keySet()) {
+      if (!(key instanceof String)) {
+        throw new EvalException(
+            loc, String.format("Invalid key: %s. select keys must be label references", key));
+      }
+    }
+    return SelectorList.of(new SelectorValue(dict, noMatchError));
+  }
 
-  @SkylarkSignature(
+  @SkylarkCallable(
       name = "zip",
       doc =
           "Returns a <code>list</code> of <code>tuple</code>s, where the i-th tuple contains "
@@ -989,36 +920,32 @@
               + "zip([1, 2], [3, 4])  # == [(1, 3), (2, 4)]\n"
               + "zip([1, 2], [3, 4, 5])  # == [(1, 3), (2, 4)]</pre>",
       extraPositionals = @Param(name = "args", doc = "lists to zip."),
-      returnType = MutableList.class,
       useLocation = true,
       useEnvironment = true)
-  private static final BuiltinFunction zip =
-      new BuiltinFunction("zip") {
-        public MutableList<?> invoke(SkylarkList<?> args, Location loc, Environment env)
-            throws EvalException {
-          Iterator<?>[] iterators = new Iterator<?>[args.size()];
-          for (int i = 0; i < args.size(); i++) {
-            iterators[i] = EvalUtils.toIterable(args.get(i), loc, env).iterator();
-          }
-          ArrayList<Tuple<?>> result = new ArrayList<>();
-          boolean allHasNext;
-          do {
-            allHasNext = !args.isEmpty();
-            List<Object> elem = Lists.newArrayListWithExpectedSize(args.size());
-            for (Iterator<?> iterator : iterators) {
-              if (iterator.hasNext()) {
-                elem.add(iterator.next());
-              } else {
-                allHasNext = false;
-              }
-            }
-            if (allHasNext) {
-              result.add(Tuple.copyOf(elem));
-            }
-          } while (allHasNext);
-          return MutableList.wrapUnsafe(env, result);
+  public MutableList<?> zip(SkylarkList<?> args, Location loc, Environment env)
+      throws EvalException {
+    Iterator<?>[] iterators = new Iterator<?>[args.size()];
+    for (int i = 0; i < args.size(); i++) {
+      iterators[i] = EvalUtils.toIterable(args.get(i), loc, env).iterator();
+    }
+    ArrayList<Tuple<?>> result = new ArrayList<>();
+    boolean allHasNext;
+    do {
+      allHasNext = !args.isEmpty();
+      List<Object> elem = Lists.newArrayListWithExpectedSize(args.size());
+      for (Iterator<?> iterator : iterators) {
+        if (iterator.hasNext()) {
+          elem.add(iterator.next());
+        } else {
+          allHasNext = false;
         }
-      };
+      }
+      if (allHasNext) {
+        result.add(Tuple.copyOf(elem));
+      }
+    } while (allHasNext);
+    return MutableList.wrapUnsafe(env, result);
+  }
 
   /** Skylark int type. */
   @SkylarkModule(
@@ -1053,17 +980,6 @@
 
   /** Adds bindings for all the builtin functions of this class to the given map builder. */
   public static void addBindingsToBuilder(ImmutableMap.Builder<String, Object> builder) {
-    for (BaseFunction function : allFunctions) {
-      builder.put(function.getName(), function);
-    }
-  }
-
-  private static final ImmutableList<BaseFunction> allFunctions =
-      ImmutableList.of(
-          all, any, bool, depset, dict, dir, fail, getattr, hasattr, hash, enumerate, int_, len,
-          list, max, min, print, range, repr, reversed, select, sorted, str, tuple, type, zip);
-
-  static {
-    SkylarkSignatureProcessor.configureSkylarkFunctions(MethodLibrary.class);
+    Runtime.setupSkylarkLibrary(builder, new MethodLibrary());
   }
 }
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/ParamDescriptor.java b/src/main/java/com/google/devtools/build/lib/syntax/ParamDescriptor.java
index 7a47cc1..e44b45d 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/ParamDescriptor.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/ParamDescriptor.java
@@ -73,7 +73,11 @@
     this.flagResponsibleForDisable = flagResponsibleForDisable;
   }
 
-  static ParamDescriptor of(Param param, StarlarkSemantics starlarkSemantics) {
+  /**
+   * Returns a {@link ParamDescriptor} representing the given raw {@link Param} annotation and the
+   * given semantics.
+   */
+  public static ParamDescriptor of(Param param, StarlarkSemantics starlarkSemantics) {
     ImmutableList<ParamTypeDescriptor> allowedTypes =
         Arrays.stream(param.allowedTypes())
             .map(ParamTypeDescriptor::of)
diff --git a/src/test/java/com/google/devtools/build/lib/skylark/SkylarkRuleImplementationFunctionsTest.java b/src/test/java/com/google/devtools/build/lib/skylark/SkylarkRuleImplementationFunctionsTest.java
index 7656031..3f37168 100644
--- a/src/test/java/com/google/devtools/build/lib/skylark/SkylarkRuleImplementationFunctionsTest.java
+++ b/src/test/java/com/google/devtools/build/lib/skylark/SkylarkRuleImplementationFunctionsTest.java
@@ -2022,7 +2022,9 @@
         "silly_rule(name = 'silly')");
     thrown.handleAssertionErrors(); // Compatibility with JUnit 4.11
     thrown.expect(AssertionError.class);
-    thrown.expectMessage("<rule context for //test:silly> is not of type string or int or bool");
+    thrown.expectMessage(
+        "expected value of type 'function' for parameter 'implementation', "
+            + "for call to function rule");
     getConfiguredTarget("//test:silly");
   }
 
diff --git a/src/test/java/com/google/devtools/build/lib/skylark/SkylarkStringRepresentationsTest.java b/src/test/java/com/google/devtools/build/lib/skylark/SkylarkStringRepresentationsTest.java
index d1c833f..52590c1 100644
--- a/src/test/java/com/google/devtools/build/lib/skylark/SkylarkStringRepresentationsTest.java
+++ b/src/test/java/com/google/devtools/build/lib/skylark/SkylarkStringRepresentationsTest.java
@@ -267,12 +267,12 @@
   @Test
   public void testStringRepresentations_Rules() throws Exception {
     assertStringRepresentation("native.cc_library", "<built-in rule cc_library>");
-    assertStringRepresentation("rule(implementation=str)", "<rule>");
+    assertStringRepresentation("def f(): pass", "rule(implementation=f)", "<rule>");
   }
 
   @Test
   public void testStringRepresentations_Aspects() throws Exception {
-    assertStringRepresentation("aspect(implementation=str)", "<aspect>");
+    assertStringRepresentation("def f(): pass", "aspect(implementation=f)", "<aspect>");
   }
 
   @Test
diff --git a/src/test/java/com/google/devtools/build/lib/syntax/MethodLibraryTest.java b/src/test/java/com/google/devtools/build/lib/syntax/MethodLibraryTest.java
index 12d3287..bf4cc44 100644
--- a/src/test/java/com/google/devtools/build/lib/syntax/MethodLibraryTest.java
+++ b/src/test/java/com/google/devtools/build/lib/syntax/MethodLibraryTest.java
@@ -335,7 +335,8 @@
             "dict('a')")
         .testIfErrorContains("cannot convert item #0 to a sequence", "dict(['a'])")
         .testIfErrorContains("cannot convert item #0 to a sequence", "dict([('a')])")
-        .testIfErrorContains("too many (3) positional arguments", "dict((3,4), (3,2), (1,2))")
+        .testIfErrorContains(
+            "expected no more than 1 positional arguments, but got 3", "dict((3,4), (3,2), (1,2))")
         .testIfErrorContains(
             "item #0 has length 3, but exactly two elements are required",
             "dict([('a', 'b', 'c')])");
@@ -464,8 +465,8 @@
         .testStatement("hash('skylark')", "skylark".hashCode())
         .testStatement("hash('google')", "google".hashCode())
         .testIfErrorContains(
-            "argument 'value' has type 'NoneType', but should be 'string'\n"
-                + "in call to builtin function hash(value)",
+            "expected value of type 'string' for parameter 'value', "
+                + "for call to function hash(value)",
             "hash(None)");
   }
 
@@ -534,8 +535,8 @@
   public void testEnumerateBadArg() throws Exception {
     new BothModesTest()
         .testIfErrorContains(
-            "argument 'list' has type 'string', but should be 'sequence'\n"
-                + "in call to builtin function enumerate(list)",
+            "expected value of type 'sequence' for parameter 'list', "
+                + "for call to function enumerate(list)",
             "enumerate('a')");
   }
 
diff --git a/src/test/java/com/google/devtools/build/lib/syntax/RuntimeTest.java b/src/test/java/com/google/devtools/build/lib/syntax/RuntimeTest.java
index e2fc1e6..5444ef8 100644
--- a/src/test/java/com/google/devtools/build/lib/syntax/RuntimeTest.java
+++ b/src/test/java/com/google/devtools/build/lib/syntax/RuntimeTest.java
@@ -19,7 +19,6 @@
 
 import com.google.devtools.build.lib.skylarkinterface.SkylarkPrinter;
 import com.google.devtools.build.lib.skylarkinterface.SkylarkValue;
-import java.lang.reflect.Field;
 import java.util.List;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -106,13 +105,4 @@
         .matches("Attempted to register function 'dummyFunc' in namespace '(.*)DummyType' after "
             + "registry has already been frozen");
   }
-
-  @Test
-  public void checkStaticallyRegistered_Global() throws Exception {
-    Field lenField = MethodLibrary.class.getDeclaredField("len");
-    lenField.setAccessible(true);
-    Object lenFieldValue = lenField.get(null);
-    List<Object> builtins = Runtime.getBuiltinRegistry().getBuiltins();
-    assertThat(builtins).contains(lenFieldValue);
-  }
 }
diff --git a/src/test/java/com/google/devtools/build/lib/syntax/SkylarkEvaluationTest.java b/src/test/java/com/google/devtools/build/lib/syntax/SkylarkEvaluationTest.java
index 4f2a446..1cd50c0 100644
--- a/src/test/java/com/google/devtools/build/lib/syntax/SkylarkEvaluationTest.java
+++ b/src/test/java/com/google/devtools/build/lib/syntax/SkylarkEvaluationTest.java
@@ -1998,9 +1998,10 @@
 
   @Test
   public void testPrintBadKwargs() throws Exception {
-    new SkylarkTest().testIfExactError(
-        "unexpected keywords 'end', 'other' in call to print(*args, sep: string = \" \")",
-        "print(end='x', other='y')");
+    new SkylarkTest()
+        .testIfErrorContains(
+            "unexpected keywords 'end', 'other', for call to function print(sep = \" \", *args)",
+            "print(end='x', other='y')");
   }
 
   // Override tests in EvaluationTest incompatible with Skylark
diff --git a/src/test/java/com/google/devtools/build/lib/syntax/SkylarkNestedSetTest.java b/src/test/java/com/google/devtools/build/lib/syntax/SkylarkNestedSetTest.java
index 40e13e4..ed522f7 100644
--- a/src/test/java/com/google/devtools/build/lib/syntax/SkylarkNestedSetTest.java
+++ b/src/test/java/com/google/devtools/build/lib/syntax/SkylarkNestedSetTest.java
@@ -266,12 +266,11 @@
 
   @Test
   public void testTooManyPositionals() throws Exception {
-    new BothModesTest().testIfExactError(
-        "too many (3) positional arguments in call to "
-            + "depset(items = [], order: string = \"default\", *, "
-            + "direct: sequence or NoneType = None, "
-            + "transitive: sequence of depsets or NoneType = None)",
-        "depset([], 'default', [])");
+    new BothModesTest()
+        .testIfErrorContains(
+            "expected no more than 2 positional arguments, but got 3, for call to function "
+                + "depset(items = [], order = \"default\", direct = None, transitive = None)",
+            "depset([], 'default', [])");
   }
 
 
diff --git a/src/test/starlark/testdata/int_constructor.sky b/src/test/starlark/testdata/int_constructor.sky
index 03c43e4..f6ee91e 100644
--- a/src/test/starlark/testdata/int_constructor.sky
+++ b/src/test/starlark/testdata/int_constructor.sky
@@ -23,7 +23,7 @@
 ---
 int('ab') ### invalid literal for int\(\) with base 10: "ab"
 ---
-int(None) ### None is not of type string or int or bool
+int(None) ### parameter 'x' cannot be None, for call to function int(x, base = unbound)
 ---
 int('123', 3) ### invalid literal for int\(\) with base 3: "123"
 ---
diff --git a/src/test/starlark/testdata/int_function.sky b/src/test/starlark/testdata/int_function.sky
index 7d6a382..29d066f 100644
--- a/src/test/starlark/testdata/int_function.sky
+++ b/src/test/starlark/testdata/int_function.sky
@@ -10,10 +10,10 @@
 assert_eq(int(False), 0)
 
 ---
-int(None) ### None is not of type string or int or bool
+int(None) ### parameter 'x' cannot be None, for call to function int(x, base = unbound)
 ---
 # This case is allowed in Python but not Skylark
-int() ### insufficient arguments received
+int() ### parameter 'x' has no default value, for call to function int(x, base = unbound)
 ---
 
 # string, no base
diff --git a/src/test/starlark/testdata/reversed.sky b/src/test/starlark/testdata/reversed.sky
index 08beba8..bf14c68 100644
--- a/src/test/starlark/testdata/reversed.sky
+++ b/src/test/starlark/testdata/reversed.sky
@@ -7,7 +7,7 @@
 assert_eq(reversed('bbb'.elems()), ['b', 'b', 'b'])
 
 ---
-reversed(None) ### type 'NoneType' is not iterable
+reversed(None) ### parameter 'sequence' cannot be None, for call to function reversed(sequence)
 ---
 reversed(1) ### type 'int' is not iterable
 ---
diff --git a/src/tools/skylark/java/com/google/devtools/skylark/skylint/Environment.java b/src/tools/skylark/java/com/google/devtools/skylark/skylint/Environment.java
index 68d18e9..f0ae3e7 100644
--- a/src/tools/skylark/java/com/google/devtools/skylark/skylint/Environment.java
+++ b/src/tools/skylark/java/com/google/devtools/skylark/skylint/Environment.java
@@ -14,6 +14,7 @@
 
 package com.google.devtools.skylark.skylint;
 
+import com.google.common.collect.ImmutableMap;
 import com.google.devtools.build.lib.packages.BazelLibrary;
 import com.google.devtools.build.lib.skylarkinterface.SkylarkSignature;
 import com.google.devtools.build.lib.syntax.ASTNode;
@@ -49,7 +50,12 @@
     env.addBuiltin("None");
     env.addBuiltin("True");
     env.addBuiltin("False");
-    env.setupFunctions(MethodLibrary.class, BazelLibrary.class);
+    env.setupFunctions(BazelLibrary.class);
+    ImmutableMap.Builder<String, Object> builtinMap = ImmutableMap.builder();
+    MethodLibrary.addBindingsToBuilder(builtinMap);
+    for (String builtinName : builtinMap.build().keySet()) {
+      env.addBuiltin(builtinName);
+    }
     return env;
   }