diff --git a/src/test/java/com/google/devtools/build/docgen/RuleDocumentationAttributeTest.java b/src/test/java/com/google/devtools/build/docgen/RuleDocumentationAttributeTest.java
index c5a5667..76bb485 100644
--- a/src/test/java/com/google/devtools/build/docgen/RuleDocumentationAttributeTest.java
+++ b/src/test/java/com/google/devtools/build/docgen/RuleDocumentationAttributeTest.java
@@ -23,6 +23,7 @@
 import com.google.devtools.build.lib.packages.BuildType;
 import com.google.devtools.build.lib.packages.Type;
 import com.google.devtools.build.lib.rules.cpp.CppFileTypes;
+import net.starlark.java.eval.StarlarkInt;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
@@ -116,7 +117,7 @@
 
   @Test
   public void testSynopsisForIntegerAttribute() {
-    final int defaultValue = 384;
+    StarlarkInt defaultValue = StarlarkInt.of(384);
     Attribute attribute = Attribute.attr("bar_limit", Type.INTEGER)
         .value(defaultValue).build();
     RuleDocumentationAttribute attributeDoc = RuleDocumentationAttribute.create(
diff --git a/src/test/java/com/google/devtools/build/lib/analysis/StarlarkAttrTransitionProviderTest.java b/src/test/java/com/google/devtools/build/lib/analysis/StarlarkAttrTransitionProviderTest.java
index fce6873..70aa7e0 100644
--- a/src/test/java/com/google/devtools/build/lib/analysis/StarlarkAttrTransitionProviderTest.java
+++ b/src/test/java/com/google/devtools/build/lib/analysis/StarlarkAttrTransitionProviderTest.java
@@ -46,6 +46,7 @@
 import java.util.stream.Collectors;
 import net.starlark.java.eval.Dict;
 import net.starlark.java.eval.Starlark;
+import net.starlark.java.eval.StarlarkInt;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -1050,7 +1051,7 @@
                 .getOptions()
                 .getStarlarkOptions()
                 .get(Label.parseAbsoluteUnchecked("//test/starlark:the-answer")))
-        .isEqualTo(42);
+        .isEqualTo(StarlarkInt.of(42));
   }
 
   @Test
@@ -1084,7 +1085,7 @@
                 .getOptions()
                 .getStarlarkOptions()
                 .get(Label.parseAbsoluteUnchecked("//test/starlark:the-answer")))
-        .isEqualTo(42);
+        .isEqualTo(StarlarkInt.of(42));
   }
 
   private CoreOptions getCoreOptions(ConfiguredTarget target) {
diff --git a/src/test/java/com/google/devtools/build/lib/collect/nestedset/DepsetTest.java b/src/test/java/com/google/devtools/build/lib/collect/nestedset/DepsetTest.java
index 5ef6a39..9eacd9e 100644
--- a/src/test/java/com/google/devtools/build/lib/collect/nestedset/DepsetTest.java
+++ b/src/test/java/com/google/devtools/build/lib/collect/nestedset/DepsetTest.java
@@ -22,6 +22,7 @@
 import net.starlark.java.eval.Dict;
 import net.starlark.java.eval.Sequence;
 import net.starlark.java.eval.StarlarkCallable;
+import net.starlark.java.eval.StarlarkInt;
 import net.starlark.java.eval.StarlarkIterable;
 import net.starlark.java.eval.StarlarkList;
 import net.starlark.java.eval.StarlarkValue;
@@ -68,7 +69,10 @@
             Tuple.of("1", "3", "5"), Tuple.of("1", "2"), Tuple.of("3", "4"), Tuple.of("5", "6"));
     assertThat(get("s_eight").getSet(Tuple.class).toList())
         .containsExactly(
-            Tuple.of(1, 3), Tuple.of("1", "2"), Tuple.of("3", "4"), Tuple.of("5", "6"));
+            Tuple.of(StarlarkInt.of(1), StarlarkInt.of(3)),
+            Tuple.of("1", "2"),
+            Tuple.of("3", "4"),
+            Tuple.of("5", "6"));
   }
 
   @Test
@@ -76,12 +80,14 @@
     ev.exec("s = depset(['a', 'b'])");
     assertThat(get("s").getSet(String.class).toList()).containsExactly("a", "b").inOrder();
     assertThat(get("s").getSet(Object.class).toList()).containsExactly("a", "b").inOrder();
-    assertThrows(Depset.TypeException.class, () -> get("s").getSet(Integer.class));
+    assertThrows(Depset.TypeException.class, () -> get("s").getSet(StarlarkInt.class));
 
     // getSet argument must be a legal Starlark value class, or Object,
     // but not some superclass that doesn't implement StarlarkValue.
-    Depset ints = Depset.legacyOf(Order.STABLE_ORDER, Tuple.of(1, 2, 3));
-    assertThat(ints.getSet(Integer.class).toString()).isEqualTo("[1, 2, 3]");
+    Depset ints =
+        Depset.legacyOf(
+            Order.STABLE_ORDER, Tuple.of(StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3)));
+    assertThat(ints.getSet(StarlarkInt.class).toString()).isEqualTo("[1, 2, 3]");
     IllegalArgumentException ex =
         assertThrows(IllegalArgumentException.class, () -> ints.getSet(Number.class));
     assertThat(ex.getMessage()).contains("Number is not a subclass of StarlarkValue");
@@ -92,7 +98,7 @@
     ev.exec("s = depset(direct = ['a', 'b'])");
     assertThat(get("s").getSet(String.class).toList()).containsExactly("a", "b").inOrder();
     assertThat(get("s").getSet(Object.class).toList()).containsExactly("a", "b").inOrder();
-    assertThrows(Depset.TypeException.class, () -> get("s").getSet(Integer.class));
+    assertThrows(Depset.TypeException.class, () -> get("s").getSet(StarlarkInt.class));
   }
 
   @Test
@@ -100,7 +106,7 @@
     ev.exec("s = depset(items = ['a', 'b'])");
     assertThat(get("s").getSet(String.class).toList()).containsExactly("a", "b").inOrder();
     assertThat(get("s").getSet(Object.class).toList()).containsExactly("a", "b").inOrder();
-    assertThrows(Depset.TypeException.class, () -> get("s").getSet(Integer.class));
+    assertThrows(Depset.TypeException.class, () -> get("s").getSet(StarlarkInt.class));
   }
 
   @Test
@@ -109,7 +115,7 @@
     assertThat(get("s").toList(String.class)).containsExactly("a", "b").inOrder();
     assertThat(get("s").toList(Object.class)).containsExactly("a", "b").inOrder();
     assertThat(get("s").toList()).containsExactly("a", "b").inOrder();
-    assertThrows(Depset.TypeException.class, () -> get("s").toList(Integer.class));
+    assertThrows(Depset.TypeException.class, () -> get("s").toList(StarlarkInt.class));
   }
 
   @Test
@@ -118,7 +124,7 @@
     assertThat(get("s").toList(String.class)).containsExactly("a", "b").inOrder();
     assertThat(get("s").toList(Object.class)).containsExactly("a", "b").inOrder();
     assertThat(get("s").toList()).containsExactly("a", "b").inOrder();
-    assertThrows(Depset.TypeException.class, () -> get("s").toList(Integer.class));
+    assertThrows(Depset.TypeException.class, () -> get("s").toList(StarlarkInt.class));
   }
 
   @Test
@@ -127,7 +133,7 @@
     assertThat(get("s").toList(String.class)).containsExactly("a", "b").inOrder();
     assertThat(get("s").toList(Object.class)).containsExactly("a", "b").inOrder();
     assertThat(get("s").toList()).containsExactly("a", "b").inOrder();
-    assertThrows(Depset.TypeException.class, () -> get("s").toList(Integer.class));
+    assertThrows(Depset.TypeException.class, () -> get("s").toList(StarlarkInt.class));
   }
 
   @Test
@@ -322,10 +328,11 @@
 
   @Test
   public void testToListForStarlark() throws Exception {
-    ev.exec("s = depset([3, 4, 5], transitive = [depset([2, 4, 6])])", "x = s.to_list()");
-    Object value = ev.lookup("x");
-    assertThat(value).isInstanceOf(StarlarkList.class);
-    assertThat((Iterable<?>) value).containsExactly(2, 4, 6, 3, 5).inOrder();
+    ev.exec(
+        "s = depset([3, 4, 5], transitive = [depset([2, 4, 6])])",
+        "x = s.to_list()",
+        "y = [2, 4, 6, 3, 5]");
+    assertThat(ev.lookup("x")).isEqualTo(ev.lookup("y"));
   }
 
   @Test
@@ -469,7 +476,7 @@
   public void testElementTypeOf() {
     // legal values
     assertThat(ElementType.of(String.class).toString()).isEqualTo("string");
-    assertThat(ElementType.of(Integer.class).toString()).isEqualTo("int");
+    assertThat(ElementType.of(StarlarkInt.class).toString()).isEqualTo("int");
     assertThat(ElementType.of(Boolean.class).toString()).isEqualTo("bool");
 
     // concrete non-values
diff --git a/src/test/java/com/google/devtools/build/lib/packages/AttributeTest.java b/src/test/java/com/google/devtools/build/lib/packages/AttributeTest.java
index 998a9fe..75b4d8e 100644
--- a/src/test/java/com/google/devtools/build/lib/packages/AttributeTest.java
+++ b/src/test/java/com/google/devtools/build/lib/packages/AttributeTest.java
@@ -42,6 +42,7 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
+import net.starlark.java.eval.StarlarkInt;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
@@ -60,9 +61,9 @@
 
   @Test
   public void testBasics() throws Exception {
-    Attribute attr = attr("foo", Type.INTEGER).mandatory().value(3).build();
+    Attribute attr = attr("foo", Type.INTEGER).mandatory().value(StarlarkInt.of(3)).build();
     assertThat(attr.getName()).isEqualTo("foo");
-    assertThat(attr.getDefaultValue(null)).isEqualTo(3);
+    assertThat(attr.getDefaultValue(null)).isEqualTo(StarlarkInt.of(3));
     assertThat(attr.getType()).isEqualTo(Type.INTEGER);
     assertThat(attr.isMandatory()).isTrue();
     assertThat(attr.isDocumented()).isTrue();
@@ -75,7 +76,7 @@
     NullPointerException e =
         assertThrows(
             NullPointerException.class,
-            () -> attr("foo", Type.INTEGER).nonEmpty().value(3).build());
+            () -> attr("foo", Type.INTEGER).nonEmpty().value(StarlarkInt.of(3)).build());
     assertThat(e).hasMessageThat().isEqualTo("attribute 'foo' must be a list");
   }
 
@@ -92,7 +93,7 @@
     IllegalStateException e =
         assertThrows(
             IllegalStateException.class,
-            () -> attr("foo", Type.INTEGER).singleArtifact().value(3).build());
+            () -> attr("foo", Type.INTEGER).singleArtifact().value(StarlarkInt.of(3)).build());
     assertThat(e).hasMessageThat().isEqualTo("attribute 'foo' must be a label-valued type");
   }
 
@@ -119,10 +120,8 @@
    */
   @Test
   public void testConvenienceFactoriesDefaultValues() throws Exception {
-    assertDefaultValue(0,
-                       attr("x", INTEGER).build());
-    assertDefaultValue(42,
-                       attr("x", INTEGER).value(42).build());
+    assertDefaultValue(StarlarkInt.of(0), attr("x", INTEGER).build());
+    assertDefaultValue(StarlarkInt.of(42), attr("x", INTEGER).value(StarlarkInt.of(42)).build());
 
     assertDefaultValue("",
                        attr("x", STRING).build());
@@ -158,8 +157,7 @@
   public void testConvenienceFactoriesTypes() throws Exception {
     assertType(INTEGER,
                attr("x", INTEGER).build());
-    assertType(INTEGER,
-               attr("x", INTEGER).value(42).build());
+    assertType(INTEGER, attr("x", INTEGER).value(StarlarkInt.of(42)).build());
 
     assertType(STRING,
                attr("x", STRING).build());
diff --git a/src/test/java/com/google/devtools/build/lib/packages/RuleClassBuilderTest.java b/src/test/java/com/google/devtools/build/lib/packages/RuleClassBuilderTest.java
index ad4c470..73e303c 100644
--- a/src/test/java/com/google/devtools/build/lib/packages/RuleClassBuilderTest.java
+++ b/src/test/java/com/google/devtools/build/lib/packages/RuleClassBuilderTest.java
@@ -30,6 +30,7 @@
 import com.google.devtools.build.lib.packages.RuleClass.Builder.RuleClassNamePredicate;
 import com.google.devtools.build.lib.packages.RuleClass.Builder.RuleClassType;
 import com.google.devtools.build.lib.packages.util.PackageLoadingTestCase;
+import net.starlark.java.eval.StarlarkInt;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
@@ -82,7 +83,7 @@
             .add(attr("size", STRING).value("medium"))
             .add(attr("timeout", STRING))
             .add(attr("flaky", BOOLEAN).value(false))
-            .add(attr("shard_count", INTEGER).value(-1))
+            .add(attr("shard_count", INTEGER).value(StarlarkInt.of(-1)))
             .add(attr("local", BOOLEAN))
             .build();
     assertThat(ruleClassA.hasBinaryOutput()).isTrue();
diff --git a/src/test/java/com/google/devtools/build/lib/packages/RuleClassTest.java b/src/test/java/com/google/devtools/build/lib/packages/RuleClassTest.java
index 1e7ee19..4512457 100644
--- a/src/test/java/com/google/devtools/build/lib/packages/RuleClassTest.java
+++ b/src/test/java/com/google/devtools/build/lib/packages/RuleClassTest.java
@@ -68,6 +68,7 @@
 import java.util.Set;
 import javax.annotation.Nullable;
 import net.starlark.java.eval.StarlarkFunction;
+import net.starlark.java.eval.StarlarkInt;
 import net.starlark.java.eval.StarlarkSemantics;
 import net.starlark.java.eval.StarlarkThread;
 import net.starlark.java.syntax.Location;
@@ -129,7 +130,7 @@
             .value(Label.parseAbsolute("//default:label", ImmutableMap.of()))
             .build(),
         attr("my-labellist-attr", LABEL_LIST).mandatory().legacyAllowAnyFileType().build(),
-        attr("my-integer-attr", INTEGER).value(42).build(),
+        attr("my-integer-attr", INTEGER).value(StarlarkInt.of(42)).build(),
         attr("my-string-attr2", STRING).mandatory().value((String) null).build(),
         attr("my-stringlist-attr", STRING_LIST).build(),
         attr("my-sorted-stringlist-attr", STRING_LIST).orderIndependent().build());
@@ -194,7 +195,7 @@
     assertThat(ruleClassA.getAttribute(1).getDefaultValue(null))
         .isEqualTo(Label.parseAbsolute("//default:label", ImmutableMap.of()));
     assertThat(ruleClassA.getAttribute(2).getDefaultValue(null)).isEqualTo(Collections.emptyList());
-    assertThat(ruleClassA.getAttribute(3).getDefaultValue(null)).isEqualTo(42);
+    assertThat(ruleClassA.getAttribute(3).getDefaultValue(null)).isEqualTo(StarlarkInt.of(42));
     // default explicitly specified
     assertThat(ruleClassA.getAttribute(4).getDefaultValue(null)).isNull();
     assertThat(ruleClassA.getAttribute(5).getDefaultValue(null)).isEqualTo(Collections.emptyList());
@@ -386,7 +387,7 @@
     AttributeMap attributes = RawAttributeMapper.of(rule);
     assertThat(attributes.get("my-label-attr", BuildType.LABEL).toString())
         .isEqualTo("//default:label");
-    assertThat(attributes.get("my-integer-attr", Type.INTEGER).intValue()).isEqualTo(42);
+    assertThat(attributes.get("my-integer-attr", Type.INTEGER).toIntUnchecked()).isEqualTo(42);
     // missing attribute -> default chosen based on type
     assertThat(attributes.get("my-string-attr", Type.STRING)).isEmpty();
     assertThat(attributes.get("my-labellist-attr", BuildType.LABEL_LIST)).isEmpty();
diff --git a/src/test/java/com/google/devtools/build/lib/packages/SelectTest.java b/src/test/java/com/google/devtools/build/lib/packages/SelectTest.java
index 418b75a..3bcd5ad 100644
--- a/src/test/java/com/google/devtools/build/lib/packages/SelectTest.java
+++ b/src/test/java/com/google/devtools/build/lib/packages/SelectTest.java
@@ -22,6 +22,7 @@
 import net.starlark.java.eval.Module;
 import net.starlark.java.eval.Mutability;
 import net.starlark.java.eval.Starlark;
+import net.starlark.java.eval.StarlarkInt;
 import net.starlark.java.eval.StarlarkSemantics;
 import net.starlark.java.eval.StarlarkThread;
 import net.starlark.java.syntax.FileOptions;
@@ -55,7 +56,7 @@
   public void testSelect() throws Exception {
     SelectorList result = (SelectorList) eval("select({'a': 1})");
     assertThat(((SelectorValue) Iterables.getOnlyElement(result.getElements())).getDictionary())
-        .containsExactly("a", 1);
+        .containsExactly("a", StarlarkInt.of(1));
   }
 
   @Test
diff --git a/src/test/java/com/google/devtools/build/lib/packages/StarlarkInfoTest.java b/src/test/java/com/google/devtools/build/lib/packages/StarlarkInfoTest.java
index d3595bd..cb34612 100644
--- a/src/test/java/com/google/devtools/build/lib/packages/StarlarkInfoTest.java
+++ b/src/test/java/com/google/devtools/build/lib/packages/StarlarkInfoTest.java
@@ -26,6 +26,7 @@
 import java.util.Random;
 import javax.annotation.Nullable;
 import net.starlark.java.eval.EvalException;
+import net.starlark.java.eval.StarlarkInt;
 import net.starlark.java.eval.StarlarkValue;
 import net.starlark.java.syntax.Location;
 import net.starlark.java.syntax.TokenKind;
@@ -46,14 +47,14 @@
   @Test
   public void instancesOfUnexportedProvidersAreMutable() throws Exception {
     StarlarkProvider provider = makeProvider();
-    StarlarkInfo info = makeInfoWithF1F2Values(provider, 5, null);
+    StarlarkInfo info = makeInfoWithF1F2Values(provider, StarlarkInt.of(5), null);
     assertThat(info.isImmutable()).isFalse();
   }
 
   @Test
   public void instancesOfExportedProvidersMayBeImmutable() throws Exception {
     StarlarkProvider provider = makeExportedProvider();
-    StarlarkInfo info = makeInfoWithF1F2Values(provider, 5, null);
+    StarlarkInfo info = makeInfoWithF1F2Values(provider, StarlarkInt.of(5), null);
     assertThat(info.isImmutable()).isTrue();
   }
 
@@ -61,7 +62,7 @@
   public void mutableIfContentsAreMutable() throws Exception {
     StarlarkProvider provider = makeExportedProvider();
     StarlarkValue v = new StarlarkValue() {};
-    StarlarkInfo info = makeInfoWithF1F2Values(provider, 5, v);
+    StarlarkInfo info = makeInfoWithF1F2Values(provider, StarlarkInt.of(5), v);
     assertThat(info.isImmutable()).isFalse();
   }
 
@@ -70,25 +71,25 @@
     StarlarkProvider provider1 = makeProvider();
     StarlarkProvider provider2 = makeProvider();
     // equal providers and fields
-    assertThat(makeInfoWithF1F2Values(provider1, 4, 5))
-        .isEqualTo(makeInfoWithF1F2Values(provider1, 4, 5));
+    assertThat(makeInfoWithF1F2Values(provider1, StarlarkInt.of(4), StarlarkInt.of(5)))
+        .isEqualTo(makeInfoWithF1F2Values(provider1, StarlarkInt.of(4), StarlarkInt.of(5)));
     // different providers => unequal
-    assertThat(makeInfoWithF1F2Values(provider1, 4, 5))
-        .isNotEqualTo(makeInfoWithF1F2Values(provider2, 4, 5));
+    assertThat(makeInfoWithF1F2Values(provider1, StarlarkInt.of(4), StarlarkInt.of(5)))
+        .isNotEqualTo(makeInfoWithF1F2Values(provider2, StarlarkInt.of(4), StarlarkInt.of(5)));
     // different fields => unequal
-    assertThat(makeInfoWithF1F2Values(provider1, 4, 5))
-        .isNotEqualTo(makeInfoWithF1F2Values(provider1, 4, 6));
+    assertThat(makeInfoWithF1F2Values(provider1, StarlarkInt.of(4), StarlarkInt.of(5)))
+        .isNotEqualTo(makeInfoWithF1F2Values(provider1, StarlarkInt.of(4), StarlarkInt.of(6)));
     // different sets of fields => unequal
-    assertThat(makeInfoWithF1F2Values(provider1, 4, 5))
-        .isNotEqualTo(makeInfoWithF1F2Values(provider1, 4, null));
+    assertThat(makeInfoWithF1F2Values(provider1, StarlarkInt.of(4), StarlarkInt.of(5)))
+        .isNotEqualTo(makeInfoWithF1F2Values(provider1, StarlarkInt.of(4), null));
   }
 
   @Test
   public void concatWithDifferentProvidersFails() throws Exception {
     StarlarkProvider provider1 = makeProvider();
     StarlarkProvider provider2 = makeProvider();
-    StarlarkInfo info1 = makeInfoWithF1F2Values(provider1, 4, 5);
-    StarlarkInfo info2 = makeInfoWithF1F2Values(provider2, 4, 5);
+    StarlarkInfo info1 = makeInfoWithF1F2Values(provider1, StarlarkInt.of(4), StarlarkInt.of(5));
+    StarlarkInfo info2 = makeInfoWithF1F2Values(provider2, StarlarkInt.of(4), StarlarkInt.of(5));
     EvalException expected =
         assertThrows(EvalException.class, () -> info1.binaryOp(TokenKind.PLUS, info2, true));
     assertThat(expected).hasMessageThat()
@@ -98,8 +99,8 @@
   @Test
   public void concatWithOverlappingFieldsFails() throws Exception {
     StarlarkProvider provider1 = makeProvider();
-    StarlarkInfo info1 = makeInfoWithF1F2Values(provider1, 4, 5);
-    StarlarkInfo info2 = makeInfoWithF1F2Values(provider1, 4, null);
+    StarlarkInfo info1 = makeInfoWithF1F2Values(provider1, StarlarkInt.of(4), StarlarkInt.of(5));
+    StarlarkInfo info2 = makeInfoWithF1F2Values(provider1, StarlarkInt.of(4), null);
     EvalException expected =
         assertThrows(EvalException.class, () -> info1.binaryOp(TokenKind.PLUS, info2, true));
     assertThat(expected)
@@ -110,23 +111,23 @@
   @Test
   public void concatWithSameFields() throws Exception {
     StarlarkProvider provider = makeProvider();
-    StarlarkInfo info1 = makeInfoWithF1F2Values(provider, 4, null);
-    StarlarkInfo info2 = makeInfoWithF1F2Values(provider, null, 5);
+    StarlarkInfo info1 = makeInfoWithF1F2Values(provider, StarlarkInt.of(4), null);
+    StarlarkInfo info2 = makeInfoWithF1F2Values(provider, null, StarlarkInt.of(5));
     StarlarkInfo result = info1.binaryOp(TokenKind.PLUS, info2, true);
     assertThat(result.getFieldNames()).containsExactly("f1", "f2");
-    assertThat(result.getValue("f1")).isEqualTo(4);
-    assertThat(result.getValue("f2")).isEqualTo(5);
+    assertThat(result.getValue("f1")).isEqualTo(StarlarkInt.of(4));
+    assertThat(result.getValue("f2")).isEqualTo(StarlarkInt.of(5));
   }
 
   @Test
   public void concatWithDifferentFields() throws Exception {
     StarlarkProvider provider = makeProvider();
-    StarlarkInfo info1 = makeInfoWithF1F2Values(provider, 4, null);
-    StarlarkInfo info2 = makeInfoWithF1F2Values(provider, null, 5);
+    StarlarkInfo info1 = makeInfoWithF1F2Values(provider, StarlarkInt.of(4), null);
+    StarlarkInfo info2 = makeInfoWithF1F2Values(provider, null, StarlarkInt.of(5));
     StarlarkInfo result = info1.binaryOp(TokenKind.PLUS, info2, true);
     assertThat(result.getFieldNames()).containsExactly("f1", "f2");
-    assertThat(result.getValue("f1")).isEqualTo(4);
-    assertThat(result.getValue("f2")).isEqualTo(5);
+    assertThat(result.getValue("f1")).isEqualTo(StarlarkInt.of(4));
+    assertThat(result.getValue("f2")).isEqualTo(StarlarkInt.of(5));
   }
 
   /** Creates an unexported schemaless provider type with builtin location. */
diff --git a/src/test/java/com/google/devtools/build/lib/packages/TypeTest.java b/src/test/java/com/google/devtools/build/lib/packages/TypeTest.java
index 7265c0d..776e183 100644
--- a/src/test/java/com/google/devtools/build/lib/packages/TypeTest.java
+++ b/src/test/java/com/google/devtools/build/lib/packages/TypeTest.java
@@ -28,6 +28,7 @@
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
+import net.starlark.java.eval.StarlarkInt;
 import net.starlark.java.eval.StarlarkList;
 import net.starlark.java.eval.Tuple;
 import org.junit.Before;
@@ -50,9 +51,27 @@
 
   @Test
   public void testInteger() throws Exception {
-    Object x = 3;
+    Object x = StarlarkInt.of(3);
     assertThat(Type.INTEGER.convert(x, null)).isEqualTo(x);
     assertThat(collectLabels(Type.INTEGER, x)).isEmpty();
+
+    // INTEGER rule attributes must be in signed 32-bit value range.
+    // (If we ever relax this, we'll need to audit every place that
+    // converts an attribute to an int using toIntUnchecked, since
+    // that operation might then fail, and extend the Package
+    // serialization protocol to support bigint.)
+    StarlarkInt big = StarlarkInt.of(111111111);
+    Type.ConversionException e =
+        assertThrows(
+            Type.ConversionException.class,
+            () -> Type.INTEGER.convert(StarlarkInt.multiply(big, big), "param"));
+    assertThat(e)
+        .hasMessageThat()
+        .contains("for param, got 12345678987654321, want value in signed 32-bit range");
+
+    // Ensure that the range of INTEGER.concat is int32.
+    assertThat(Type.INTEGER.concat(Arrays.asList(StarlarkInt.of(0x7fffffff), StarlarkInt.of(1))))
+        .isEqualTo(StarlarkInt.of(-0x80000000));
   }
 
   @Test
@@ -96,8 +115,8 @@
   public void testBoolean() throws Exception {
     Object myTrue = true;
     Object myFalse = false;
-    assertThat(Type.BOOLEAN.convert(1, null)).isEqualTo(Boolean.TRUE);
-    assertThat(Type.BOOLEAN.convert(0, null)).isEqualTo(Boolean.FALSE);
+    assertThat(Type.BOOLEAN.convert(StarlarkInt.of(1), null)).isEqualTo(Boolean.TRUE);
+    assertThat(Type.BOOLEAN.convert(StarlarkInt.of(0), null)).isEqualTo(Boolean.FALSE);
     assertThat(Type.BOOLEAN.convert(true, null)).isTrue();
     assertThat(Type.BOOLEAN.convert(myTrue, null)).isTrue();
     assertThat(Type.BOOLEAN.convert(false, null)).isFalse();
@@ -114,17 +133,21 @@
         .hasMessageThat()
         .isEqualTo("expected value of type 'int', but got \"unexpected\" (string)");
     // Integers other than [0, 1] should fail.
-    e = assertThrows(Type.ConversionException.class, () -> Type.BOOLEAN.convert(2, null));
+    e =
+        assertThrows(
+            Type.ConversionException.class, () -> Type.BOOLEAN.convert(StarlarkInt.of(2), null));
     assertThat(e).hasMessageThat().isEqualTo("boolean is not one of [0, 1]");
-    e = assertThrows(Type.ConversionException.class, () -> Type.BOOLEAN.convert(-1, null));
+    e =
+        assertThrows(
+            Type.ConversionException.class, () -> Type.BOOLEAN.convert(StarlarkInt.of(-1), null));
     assertThat(e).hasMessageThat().isEqualTo("boolean is not one of [0, 1]");
   }
 
   @Test
   public void testTriState() throws Exception {
-    assertThat(BuildType.TRISTATE.convert(1, null)).isEqualTo(TriState.YES);
-    assertThat(BuildType.TRISTATE.convert(0, null)).isEqualTo(TriState.NO);
-    assertThat(BuildType.TRISTATE.convert(-1, null)).isEqualTo(TriState.AUTO);
+    assertThat(BuildType.TRISTATE.convert(StarlarkInt.of(1), null)).isEqualTo(TriState.YES);
+    assertThat(BuildType.TRISTATE.convert(StarlarkInt.of(0), null)).isEqualTo(TriState.NO);
+    assertThat(BuildType.TRISTATE.convert(StarlarkInt.of(-1), null)).isEqualTo(TriState.AUTO);
     assertThat(BuildType.TRISTATE.convert(TriState.YES, null)).isEqualTo(TriState.YES);
     assertThat(BuildType.TRISTATE.convert(TriState.NO, null)).isEqualTo(TriState.NO);
     assertThat(BuildType.TRISTATE.convert(TriState.AUTO, null)).isEqualTo(TriState.AUTO);
@@ -137,9 +160,10 @@
 
   @Test
   public void testTriStateDoesNotAcceptArbitraryIntegers() throws Exception {
-    List<Integer> listOfCases = Lists.newArrayList(2, 3, -5, -2, 20);
-    for (Object entry : listOfCases) {
-      assertThrows(Type.ConversionException.class, () -> BuildType.TRISTATE.convert(entry, null));
+    for (Integer i : Lists.newArrayList(2, 3, -5, -2, 20)) {
+      assertThrows(
+          Type.ConversionException.class,
+          () -> BuildType.TRISTATE.convert(StarlarkInt.of(i), null));
     }
   }
 
diff --git a/src/test/java/com/google/devtools/build/lib/profiler/memory/AllocationTrackerTest.java b/src/test/java/com/google/devtools/build/lib/profiler/memory/AllocationTrackerTest.java
index 7991337..acee66b 100644
--- a/src/test/java/com/google/devtools/build/lib/profiler/memory/AllocationTrackerTest.java
+++ b/src/test/java/com/google/devtools/build/lib/profiler/memory/AllocationTrackerTest.java
@@ -37,6 +37,7 @@
 import net.starlark.java.eval.Mutability;
 import net.starlark.java.eval.Starlark;
 import net.starlark.java.eval.StarlarkCallable;
+import net.starlark.java.eval.StarlarkInt;
 import net.starlark.java.eval.StarlarkSemantics;
 import net.starlark.java.eval.StarlarkThread;
 import net.starlark.java.syntax.FileOptions;
@@ -64,8 +65,8 @@
   private class SamplerValue implements HasBinary {
     @Override
     public Object binaryOp(TokenKind op, Object that, boolean thisLeft) throws EvalException {
-      if (op == TokenKind.PLUS && thisLeft && that instanceof Integer) {
-        int size = (Integer) that;
+      if (op == TokenKind.PLUS && thisLeft && that instanceof StarlarkInt) {
+        int size = ((StarlarkInt) that).toIntUnchecked(); // test values are small
         Object obj = new Object();
         live.add(obj); // ensure that obj outlives the test assertions
         tracker.sampleAllocation(1, "", obj, size);
diff --git a/src/test/java/com/google/devtools/build/lib/rules/python/PyStructUtilsTest.java b/src/test/java/com/google/devtools/build/lib/rules/python/PyStructUtilsTest.java
index 7e50d69..9a3a906 100644
--- a/src/test/java/com/google/devtools/build/lib/rules/python/PyStructUtilsTest.java
+++ b/src/test/java/com/google/devtools/build/lib/rules/python/PyStructUtilsTest.java
@@ -33,6 +33,7 @@
 import java.util.LinkedHashMap;
 import java.util.Map;
 import net.starlark.java.eval.EvalException;
+import net.starlark.java.eval.StarlarkInt;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.function.ThrowingRunnable;
@@ -120,7 +121,8 @@
 
   @Test
   public void getTransitiveSources_WrongType() {
-    StructImpl info = makeStruct(ImmutableMap.of(PyStructUtils.TRANSITIVE_SOURCES, 123));
+    StructImpl info =
+        makeStruct(ImmutableMap.of(PyStructUtils.TRANSITIVE_SOURCES, StarlarkInt.of(123)));
     assertThrowsEvalExceptionContaining(
         () -> PyStructUtils.getTransitiveSources(info),
         "for transitive_sources, got int, want a depset of File");
@@ -151,7 +153,8 @@
 
   @Test
   public void getUsesSharedLibraries_WrongType() {
-    StructImpl info = makeStruct(ImmutableMap.of(PyStructUtils.USES_SHARED_LIBRARIES, 123));
+    StructImpl info =
+        makeStruct(ImmutableMap.of(PyStructUtils.USES_SHARED_LIBRARIES, StarlarkInt.of(123)));
     assertHasWrongTypeMessage(
         () -> PyStructUtils.getUsesSharedLibraries(info), "uses_shared_libraries", "bool");
   }
@@ -172,7 +175,7 @@
 
   @Test
   public void getImports_WrongType() {
-    StructImpl info = makeStruct(ImmutableMap.of(PyStructUtils.IMPORTS, 123));
+    StructImpl info = makeStruct(ImmutableMap.of(PyStructUtils.IMPORTS, StarlarkInt.of(123)));
     assertThrowsEvalExceptionContaining(
         () -> PyStructUtils.getImports(info), "for imports, got int, want a depset of string");
   }
@@ -190,7 +193,8 @@
 
   @Test
   public void getHasPy2OnlySources_WrongType() {
-    StructImpl info = makeStruct(ImmutableMap.of(PyStructUtils.HAS_PY2_ONLY_SOURCES, 123));
+    StructImpl info =
+        makeStruct(ImmutableMap.of(PyStructUtils.HAS_PY2_ONLY_SOURCES, StarlarkInt.of(123)));
     assertHasWrongTypeMessage(
         () -> PyStructUtils.getHasPy2OnlySources(info), "has_py2_only_sources", "bool");
   }
@@ -208,7 +212,8 @@
 
   @Test
   public void getHasPy3OnlySources_WrongType() {
-    StructImpl info = makeStruct(ImmutableMap.of(PyStructUtils.HAS_PY3_ONLY_SOURCES, 123));
+    StructImpl info =
+        makeStruct(ImmutableMap.of(PyStructUtils.HAS_PY3_ONLY_SOURCES, StarlarkInt.of(123)));
     assertHasWrongTypeMessage(
         () -> PyStructUtils.getHasPy3OnlySources(info), "has_py3_only_sources", "bool");
   }
diff --git a/src/test/java/com/google/devtools/build/lib/skyframe/BzlLoadFunctionTest.java b/src/test/java/com/google/devtools/build/lib/skyframe/BzlLoadFunctionTest.java
index c505229..e274f4f 100644
--- a/src/test/java/com/google/devtools/build/lib/skyframe/BzlLoadFunctionTest.java
+++ b/src/test/java/com/google/devtools/build/lib/skyframe/BzlLoadFunctionTest.java
@@ -47,6 +47,7 @@
 import java.io.InputStream;
 import java.util.UUID;
 import javax.annotation.Nullable;
+import net.starlark.java.eval.StarlarkInt;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -402,7 +403,8 @@
         SkyframeExecutorTestUtils.evaluate(
             getSkyframeExecutor(), skyKey, /*keepGoing=*/ false, reporter);
 
-    assertThat(result.get(skyKey).getModule().getGlobals()).containsEntry("a_symbol", 5);
+    assertThat(result.get(skyKey).getModule().getGlobals())
+        .containsEntry("a_symbol", StarlarkInt.of(5));
   }
 
   @Test
diff --git a/src/test/java/com/google/devtools/build/lib/skyframe/PackageFunctionTest.java b/src/test/java/com/google/devtools/build/lib/skyframe/PackageFunctionTest.java
index 3a1b30c..01c5faa 100644
--- a/src/test/java/com/google/devtools/build/lib/skyframe/PackageFunctionTest.java
+++ b/src/test/java/com/google/devtools/build/lib/skyframe/PackageFunctionTest.java
@@ -85,6 +85,7 @@
 import java.util.concurrent.atomic.AtomicInteger;
 import javax.annotation.Nullable;
 import net.starlark.java.eval.Module;
+import net.starlark.java.eval.StarlarkInt;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -1254,7 +1255,7 @@
     Module cViaB = bLoads.get(":c.bzl");
     assertThat(cViaB).isSameInstanceAs(cViaA);
 
-    assertThat(cViaA.getGlobal("c")).isEqualTo(0);
+    assertThat(cViaA.getGlobal("c")).isEqualTo(StarlarkInt.of(0));
   }
 
   @Test
diff --git a/src/test/java/com/google/devtools/build/lib/starlark/StarlarkDefinedAspectsTest.java b/src/test/java/com/google/devtools/build/lib/starlark/StarlarkDefinedAspectsTest.java
index fb74540..fb8086a 100644
--- a/src/test/java/com/google/devtools/build/lib/starlark/StarlarkDefinedAspectsTest.java
+++ b/src/test/java/com/google/devtools/build/lib/starlark/StarlarkDefinedAspectsTest.java
@@ -52,6 +52,7 @@
 import com.google.devtools.build.lib.skyframe.AspectValueKey.AspectKey;
 import com.google.devtools.build.lib.vfs.FileSystemUtils;
 import net.starlark.java.eval.Sequence;
+import net.starlark.java.eval.StarlarkInt;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -2460,7 +2461,7 @@
         new StarlarkProvider.Key(
             Label.parseAbsolute("//test:aspect.bzl", ImmutableMap.of()), "PCollector");
     StructImpl collector = (StructImpl) configuredAspect.get(pCollector);
-    assertThat(collector.getValue("attr_value")).isEqualTo(30);
+    assertThat(collector.getValue("attr_value")).isEqualTo(StarlarkInt.of(30));
   }
 
   @Test
@@ -2515,7 +2516,7 @@
         new StarlarkProvider.Key(
             Label.parseAbsolute("//test:aspect.bzl", ImmutableMap.of()), "PCollector");
     StructImpl collector = (StructImpl) configuredAspect.get(pCollector);
-    assertThat(collector.getValue("attr_value")).isEqualTo(30);
+    assertThat(collector.getValue("attr_value")).isEqualTo(StarlarkInt.of(30));
   }
 
   @Test
diff --git a/src/test/java/com/google/devtools/build/lib/starlark/StarlarkIntegrationTest.java b/src/test/java/com/google/devtools/build/lib/starlark/StarlarkIntegrationTest.java
index 8d17f32..ac0aa23 100644
--- a/src/test/java/com/google/devtools/build/lib/starlark/StarlarkIntegrationTest.java
+++ b/src/test/java/com/google/devtools/build/lib/starlark/StarlarkIntegrationTest.java
@@ -59,6 +59,7 @@
 import net.starlark.java.eval.NoneType;
 import net.starlark.java.eval.Sequence;
 import net.starlark.java.eval.Starlark;
+import net.starlark.java.eval.StarlarkInt;
 import net.starlark.java.eval.StarlarkList;
 import org.junit.Before;
 import org.junit.Test;
@@ -1412,7 +1413,7 @@
     StructImpl declaredProvider = (StructImpl) configuredTarget.get(key);
     assertThat(declaredProvider).isNotNull();
     assertThat(declaredProvider.getProvider().getKey()).isEqualTo(key);
-    assertThat(declaredProvider.getValue("x")).isEqualTo(1);
+    assertThat(declaredProvider.getValue("x")).isEqualTo(StarlarkInt.of(1));
   }
 
   @Test
@@ -1437,7 +1438,7 @@
     StructImpl declaredProvider = (StructImpl) configuredTarget.get(key);
     assertThat(declaredProvider).isNotNull();
     assertThat(declaredProvider.getProvider().getKey()).isEqualTo(key);
-    assertThat(declaredProvider.getValue("x")).isEqualTo(1);
+    assertThat(declaredProvider.getValue("x")).isEqualTo(StarlarkInt.of(1));
   }
 
   @Test
@@ -1463,7 +1464,7 @@
     StructImpl declaredProvider = (StructImpl) configuredTarget.get(key);
     assertThat(declaredProvider).isNotNull();
     assertThat(declaredProvider.getProvider().getKey()).isEqualTo(key);
-    assertThat(declaredProvider.getValue("x")).isEqualTo(1);
+    assertThat(declaredProvider.getValue("x")).isEqualTo(StarlarkInt.of(1));
   }
 
   @Test
diff --git a/src/test/java/com/google/devtools/build/lib/starlark/StarlarkOptionsParsingTest.java b/src/test/java/com/google/devtools/build/lib/starlark/StarlarkOptionsParsingTest.java
index ea16805..ab72af3 100644
--- a/src/test/java/com/google/devtools/build/lib/starlark/StarlarkOptionsParsingTest.java
+++ b/src/test/java/com/google/devtools/build/lib/starlark/StarlarkOptionsParsingTest.java
@@ -23,6 +23,7 @@
 import com.google.devtools.build.lib.util.Pair;
 import com.google.devtools.common.options.OptionsParsingException;
 import com.google.devtools.common.options.OptionsParsingResult;
+import net.starlark.java.eval.StarlarkInt;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
@@ -39,7 +40,8 @@
     OptionsParsingResult result = parseStarlarkOptions("--//test:my_int_setting=666");
 
     assertThat(result.getStarlarkOptions()).hasSize(1);
-    assertThat(result.getStarlarkOptions().get("//test:my_int_setting")).isEqualTo(666);
+    assertThat(result.getStarlarkOptions().get("//test:my_int_setting"))
+        .isEqualTo(StarlarkInt.of(666));
     assertThat(result.getResidue()).isEmpty();
   }
 
@@ -51,7 +53,8 @@
     OptionsParsingResult result = parseStarlarkOptions("--//test:my_int_setting 666");
 
     assertThat(result.getStarlarkOptions()).hasSize(1);
-    assertThat(result.getStarlarkOptions().get("//test:my_int_setting")).isEqualTo(666);
+    assertThat(result.getStarlarkOptions().get("//test:my_int_setting"))
+        .isEqualTo(StarlarkInt.of(666));
     assertThat(result.getResidue()).isEmpty();
   }
 
@@ -66,7 +69,7 @@
 
     assertThat(result.getStarlarkOptions()).hasSize(1);
     assertThat(result.getStarlarkOptions().get("@starlark_options_test//test:my_int_setting"))
-        .isEqualTo(666);
+        .isEqualTo(StarlarkInt.of(666));
     assertThat(result.getResidue()).isEmpty();
   }
 
@@ -206,7 +209,8 @@
         parseStarlarkOptions("--//test:my_int_setting=4 --//test:my_int_setting=7");
 
     assertThat(result.getStarlarkOptions()).hasSize(1);
-    assertThat(result.getStarlarkOptions().get("//test:my_int_setting")).isEqualTo(7);
+    assertThat(result.getStarlarkOptions().get("//test:my_int_setting"))
+        .isEqualTo(StarlarkInt.of(7));
     assertThat(result.getResidue()).isEmpty();
   }
 
@@ -232,8 +236,10 @@
 
     assertThat(result.getResidue()).isEmpty();
     assertThat(result.getStarlarkOptions()).hasSize(2);
-    assertThat(result.getStarlarkOptions().get("//test:my_int_setting")).isEqualTo(0);
-    assertThat(result.getStarlarkOptions().get("//test:my_other_int_setting")).isEqualTo(0);
+    assertThat(result.getStarlarkOptions().get("//test:my_int_setting"))
+        .isEqualTo(StarlarkInt.of(0));
+    assertThat(result.getStarlarkOptions().get("//test:my_other_int_setting"))
+        .isEqualTo(StarlarkInt.of(0));
   }
 
   // test --non_build_setting
@@ -318,7 +324,8 @@
 
     OptionsParsingResult result = parseStarlarkOptions("--//test:my_int_setting=15");
 
-    assertThat(result.getStarlarkOptions().get("//test:my_int_setting")).isEqualTo(15);
+    assertThat(result.getStarlarkOptions().get("//test:my_int_setting"))
+        .isEqualTo(StarlarkInt.of(15));
   }
 
   @Test
diff --git a/src/test/java/com/google/devtools/build/lib/starlark/StarlarkRuleClassFunctionsTest.java b/src/test/java/com/google/devtools/build/lib/starlark/StarlarkRuleClassFunctionsTest.java
index 7a87200..45c3d2b 100644
--- a/src/test/java/com/google/devtools/build/lib/starlark/StarlarkRuleClassFunctionsTest.java
+++ b/src/test/java/com/google/devtools/build/lib/starlark/StarlarkRuleClassFunctionsTest.java
@@ -61,6 +61,7 @@
 import net.starlark.java.eval.Module;
 import net.starlark.java.eval.Mutability;
 import net.starlark.java.eval.Starlark;
+import net.starlark.java.eval.StarlarkInt;
 import net.starlark.java.eval.StarlarkList;
 import net.starlark.java.eval.Tuple;
 import net.starlark.java.syntax.ParserInput;
@@ -639,8 +640,8 @@
   public void testAttrIntValues() throws Exception {
     Attribute attr = buildAttribute("a1", "attr.int(values = [1, 2])");
     PredicateWithMessage<Object> predicate = attr.getAllowedValues();
-    assertThat(predicate.apply(2)).isTrue();
-    assertThat(predicate.apply(3)).isFalse();
+    assertThat(predicate.apply(StarlarkInt.of(2))).isTrue();
+    assertThat(predicate.apply(StarlarkInt.of(3))).isFalse();
   }
 
   @Test
@@ -893,7 +894,50 @@
         "r1 = rule(impl, attrs = {'a1': attr.int(default = 40+2)})");
     RuleClass c = ((StarlarkRuleFunction) ev.lookup("r1")).getRuleClass();
     Attribute a = c.getAttributeByName("a1");
-    assertThat(a.getDefaultValueUnchecked()).isEqualTo(42);
+    assertThat(a.getDefaultValueUnchecked()).isEqualTo(StarlarkInt.of(42));
+  }
+
+  @Test
+  public void testIntDefaultValueMustBeInt32() throws Exception {
+    // This is a test of the loading phase. Move somewhere more appropriate.
+    ev.checkEvalErrorContains(
+        "for parameter 'default' of attribute '', got 4294967296, want value in signed 32-bit"
+            + " range",
+        "attr.int(default = 0x10000 * 0x10000)");
+    ev.checkEvalErrorContains(
+        "for element 0 of parameter 'default' of attribute '', got 4294967296, want value in"
+            + " signed 32-bit range",
+        "attr.int_list(default = [0x10000 * 0x10000])");
+  }
+
+  @Test
+  public void testIntAttributeValueMustBeInt32() throws Exception {
+    // This is a test of the loading phase. Move somewhere more appropriate.
+    scratch.file(
+        "p/inc.bzl", //
+        "def _impl(ctx): pass",
+        "r = rule(_impl, attrs = dict(i=attr.int()))");
+    scratch.file(
+        "p/BUILD", //
+        "load('inc.bzl', 'r')",
+        "r(name = 'p', i = 0x10000 * 0x10000)");
+    AssertionError expected = assertThrows(AssertionError.class, () -> createRuleContext("//p"));
+    assertThat(expected)
+        .hasMessageThat()
+        .contains(
+            "for attribute 'i' in 'r' rule, got 4294967296, want value in signed 32-bit range");
+  }
+
+  @Test
+  public void testIntegerConcatTruncates() throws Exception {
+    // The Type.INTEGER.concat operator, as used to resolve select(int)+select(int)
+    // after rule construction, has a range of int32.
+    scratch.file(
+        "p/BUILD", //
+        "s = select({'//conditions:default': -0x7fffffff})", // -0x7fffffff + -0x7fffffff = 2
+        "cc_test(name='c', shard_count = s+s)");
+    StarlarkRuleContext context = createRuleContext("//p:c");
+    assertThat(context.getAttr().getValue("shard_count")).isEqualTo(StarlarkInt.of(2));
   }
 
   @Test
@@ -1126,8 +1170,8 @@
     // TODO(fwe): cannot be handled by current testing suite
     ev.exec("x = struct(a = 1, b = 2)");
     ClassObject x = (ClassObject) ev.lookup("x");
-    assertThat(x.getValue("a")).isEqualTo(1);
-    assertThat(x.getValue("b")).isEqualTo(2);
+    assertThat(x.getValue("a")).isEqualTo(StarlarkInt.of(1));
+    assertThat(x.getValue("b")).isEqualTo(StarlarkInt.of(2));
   }
 
   @Test
@@ -1162,8 +1206,8 @@
   @Test
   public void testStructAccessingFieldsFromStarlark() throws Exception {
     ev.exec("x = struct(a = 1, b = 2)", "x1 = x.a", "x2 = x.b");
-    assertThat(ev.lookup("x1")).isEqualTo(1);
-    assertThat(ev.lookup("x2")).isEqualTo(2);
+    assertThat(ev.lookup("x1")).isEqualTo(StarlarkInt.of(1));
+    assertThat(ev.lookup("x2")).isEqualTo(StarlarkInt.of(2));
   }
 
   @Test
@@ -1189,7 +1233,7 @@
   @Test
   public void testStructAccessingFunctionFieldWithArgs() throws Exception {
     ev.exec("def f(x): return x+5", "x = struct(a = f, b = 2)", "x1 = x.a(1)");
-    assertThat(ev.lookup("x1")).isEqualTo(6);
+    assertThat(ev.lookup("x1")).isEqualTo(StarlarkInt.of(6));
   }
 
   @Test
@@ -1217,10 +1261,10 @@
         "y = struct(c = 1, d = 2)",
         "z = x + y\n");
     StructImpl z = (StructImpl) ev.lookup("z");
-    assertThat(z.getValue("a")).isEqualTo(1);
-    assertThat(z.getValue("b")).isEqualTo(2);
-    assertThat(z.getValue("c")).isEqualTo(1);
-    assertThat(z.getValue("d")).isEqualTo(2);
+    assertThat(z.getValue("a")).isEqualTo(StarlarkInt.of(1));
+    assertThat(z.getValue("b")).isEqualTo(StarlarkInt.of(2));
+    assertThat(z.getValue("c")).isEqualTo(StarlarkInt.of(1));
+    assertThat(z.getValue("d")).isEqualTo(StarlarkInt.of(2));
   }
 
   @Test
@@ -1243,10 +1287,10 @@
         "  return x",
         "x = func()");
     StructImpl x = (StructImpl) ev.lookup("x");
-    assertThat(x.getValue("a")).isEqualTo(1);
-    assertThat(x.getValue("b")).isEqualTo(2);
-    assertThat(x.getValue("c")).isEqualTo(1);
-    assertThat(x.getValue("d")).isEqualTo(2);
+    assertThat(x.getValue("a")).isEqualTo(StarlarkInt.of(1));
+    assertThat(x.getValue("b")).isEqualTo(StarlarkInt.of(2));
+    assertThat(x.getValue("c")).isEqualTo(StarlarkInt.of(1));
+    assertThat(x.getValue("d")).isEqualTo(StarlarkInt.of(2));
   }
 
   @Test
@@ -1301,7 +1345,7 @@
         "s = struct(x = {'a' : 1})", //
         "s.x['b'] = 2\n");
     assertThat(((StructImpl) ev.lookup("s")).getValue("x"))
-        .isEqualTo(ImmutableMap.of("a", 1, "b", 2));
+        .isEqualTo(ImmutableMap.of("a", StarlarkInt.of(1), "b", StarlarkInt.of(2)));
   }
 
   @Test
@@ -1324,21 +1368,22 @@
                 StarlarkList.<Object>of(
                     mu,
                     StructProvider.STRUCT.create(
-                        ImmutableMap.<String, Object>of("x", Dict.<Object, Object>of(mu, 1, 1)),
+                        ImmutableMap.<String, Object>of(
+                            "x", Dict.<Object, Object>of(mu, StarlarkInt.of(1), StarlarkInt.of(1))),
                         "no field '%s'"),
                     Tuple.of()),
             "b", Tuple.of(),
-            "c", Dict.<Object, Object>of(mu, 2, 2)),
+            "c", Dict.<Object, Object>of(mu, StarlarkInt.of(2), StarlarkInt.of(2))),
         "no field '%s'");
   }
 
   @Test
   public void testStructMutabilityShallow() throws Exception {
-    assertThat(Starlark.isImmutable(makeStruct("a", 1))).isTrue();
+    assertThat(Starlark.isImmutable(makeStruct("a", StarlarkInt.of(1)))).isTrue();
   }
 
   private static StarlarkList<Object> makeList(@Nullable Mutability mu) {
-    return StarlarkList.<Object>of(mu, 1, 2, 3);
+    return StarlarkList.<Object>of(mu, StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3));
   }
 
   @Test
@@ -1356,7 +1401,7 @@
   @Test
   public void declaredProviders() throws Exception {
     evalAndExport(ev, "data = provider()", "d = data(x = 1, y ='abc')", "d_x = d.x", "d_y = d.y");
-    assertThat(ev.lookup("d_x")).isEqualTo(1);
+    assertThat(ev.lookup("d_x")).isEqualTo(StarlarkInt.of(1));
     assertThat(ev.lookup("d_y")).isEqualTo("abc");
     StarlarkProvider dataConstructor = (StarlarkProvider) ev.lookup("data");
     StructImpl data = (StructImpl) ev.lookup("d");
@@ -1376,7 +1421,7 @@
         "dxy = dx + dy",
         "x = dxy.x",
         "y = dxy.y");
-    assertThat(ev.lookup("x")).isEqualTo(1);
+    assertThat(ev.lookup("x")).isEqualTo(StarlarkInt.of(1));
     assertThat(ev.lookup("y")).isEqualTo("abc");
     StarlarkProvider dataConstructor = (StarlarkProvider) ev.lookup("data");
     StructImpl dx = (StructImpl) ev.lookup("dx");
@@ -1406,8 +1451,8 @@
         "d3 = d1 + d2",
         "f1 = d3.f1",
         "f2 = d3.f2");
-    assertThat(ev.lookup("f1")).isEqualTo(4);
-    assertThat(ev.lookup("f2")).isEqualTo(5);
+    assertThat(ev.lookup("f1")).isEqualTo(StarlarkInt.of(4));
+    assertThat(ev.lookup("f2")).isEqualTo(StarlarkInt.of(5));
   }
 
   @Test
@@ -1632,8 +1677,8 @@
     StarlarkInfo p1 = (StarlarkInfo) ev.lookup("p1");
 
     assertThat(p1.getProvider()).isEqualTo(p);
-    assertThat(ev.lookup("x")).isEqualTo(1);
-    assertThat(ev.lookup("y")).isEqualTo(2);
+    assertThat(ev.lookup("x")).isEqualTo(StarlarkInt.of(1));
+    assertThat(ev.lookup("y")).isEqualTo(StarlarkInt.of(2));
   }
 
   @Test
@@ -1648,8 +1693,8 @@
     StarlarkInfo p1 = (StarlarkInfo) ev.lookup("p1");
 
     assertThat(p1.getProvider()).isEqualTo(p);
-    assertThat(ev.lookup("x")).isEqualTo(1);
-    assertThat(ev.lookup("y")).isEqualTo(2);
+    assertThat(ev.lookup("x")).isEqualTo(StarlarkInt.of(1));
+    assertThat(ev.lookup("y")).isEqualTo(StarlarkInt.of(2));
   }
 
   @Test
@@ -1663,7 +1708,7 @@
     StarlarkInfo p1 = (StarlarkInfo) ev.lookup("p1");
 
     assertThat(p1.getProvider()).isEqualTo(p);
-    assertThat(ev.lookup("y")).isEqualTo(2);
+    assertThat(ev.lookup("y")).isEqualTo(StarlarkInt.of(2));
   }
 
   @Test
diff --git a/src/test/java/com/google/devtools/build/lib/starlark/StarlarkRuleContextTest.java b/src/test/java/com/google/devtools/build/lib/starlark/StarlarkRuleContextTest.java
index 52465e3..de47e1d 100644
--- a/src/test/java/com/google/devtools/build/lib/starlark/StarlarkRuleContextTest.java
+++ b/src/test/java/com/google/devtools/build/lib/starlark/StarlarkRuleContextTest.java
@@ -64,6 +64,7 @@
 import net.starlark.java.eval.Mutability;
 import net.starlark.java.eval.Sequence;
 import net.starlark.java.eval.Starlark;
+import net.starlark.java.eval.StarlarkInt;
 import net.starlark.java.eval.StarlarkList;
 import org.junit.Before;
 import org.junit.Test;
@@ -2614,7 +2615,7 @@
             "BuildSettingInfo");
     StructImpl buildSettingInfo = (StructImpl) buildSetting.get(key);
 
-    assertThat(buildSettingInfo.getValue("value")).isEqualTo(24);
+    assertThat(buildSettingInfo.getValue("value")).isEqualTo(StarlarkInt.of(24));
   }
 
   @Test
@@ -2628,7 +2629,7 @@
             "BuildSettingInfo");
     StructImpl buildSettingInfo = (StructImpl) buildSetting.get(key);
 
-    assertThat(buildSettingInfo.getValue("value")).isEqualTo(42);
+    assertThat(buildSettingInfo.getValue("value")).isEqualTo(StarlarkInt.of(42));
   }
 
   @Test
diff --git a/src/test/java/com/google/devtools/build/lib/starlark/StarlarkRuleImplementationFunctionsTest.java b/src/test/java/com/google/devtools/build/lib/starlark/StarlarkRuleImplementationFunctionsTest.java
index aec46ba..f41a7c2 100644
--- a/src/test/java/com/google/devtools/build/lib/starlark/StarlarkRuleImplementationFunctionsTest.java
+++ b/src/test/java/com/google/devtools/build/lib/starlark/StarlarkRuleImplementationFunctionsTest.java
@@ -74,6 +74,7 @@
 import net.starlark.java.eval.Printer;
 import net.starlark.java.eval.Sequence;
 import net.starlark.java.eval.Starlark;
+import net.starlark.java.eval.StarlarkInt;
 import net.starlark.java.eval.StarlarkList;
 import net.starlark.java.eval.StarlarkThread;
 import org.junit.Before;
@@ -1511,7 +1512,7 @@
         .isEqualTo(
             new StarlarkProvider.Key(
                 Label.parseAbsolute("//test:foo.bzl", ImmutableMap.of()), "foo_provider"));
-    assertThat(((StructImpl) provider).getValue("a")).isEqualTo(123);
+    assertThat(((StructImpl) provider).getValue("a")).isEqualTo(StarlarkInt.of(123));
   }
 
   @Test
@@ -2311,15 +2312,15 @@
   public void testArgsAddInvalidTypesForArgAndValues() throws Exception {
     setRuleContext(createRuleContext("//foo:foo"));
     ev.checkEvalErrorContains(
-        "expected value of type 'string' for arg name, got 'Integer'",
+        "expected value of type 'string' for arg name, got 'int'",
         "args = ruleContext.actions.args()",
         "args.add(1, 'value')");
     ev.checkEvalErrorContains(
-        "expected value of type 'string' for arg name, got 'Integer'",
+        "expected value of type 'string' for arg name, got 'int'",
         "args = ruleContext.actions.args()",
         "args.add_all(1, [1, 2])");
     ev.checkEvalErrorContains(
-        "expected value of type 'sequence or depset' for values, got 'Integer'",
+        "expected value of type 'sequence or depset' for values, got 'int'",
         "args = ruleContext.actions.args()",
         "args.add_all(1)");
     ev.checkEvalErrorContains(
@@ -2417,7 +2418,7 @@
     CommandLineExpansionException e =
         assertThrows(CommandLineExpansionException.class, () -> action.getArguments());
     assertThat(e.getMessage())
-        .contains("Expected map_each to return string, None, or list of strings, found Integer");
+        .contains("Expected map_each to return string, None, or list of strings, found int");
   }
 
   @Test
diff --git a/src/test/java/net/starlark/java/eval/BUILD b/src/test/java/net/starlark/java/eval/BUILD
index a0de839..896039d 100644
--- a/src/test/java/net/starlark/java/eval/BUILD
+++ b/src/test/java/net/starlark/java/eval/BUILD
@@ -56,7 +56,6 @@
         "testdata/function.sky",
         "testdata/int.sky",
         "testdata/int_constructor.sky",
-        "testdata/int_function.sky",
         "testdata/list_mutation.sky",
         "testdata/list_slices.sky",
         "testdata/min_max.sky",
diff --git a/src/test/java/net/starlark/java/eval/EvalUtilsTest.java b/src/test/java/net/starlark/java/eval/EvalUtilsTest.java
index 0054d63..71bd1f7 100644
--- a/src/test/java/net/starlark/java/eval/EvalUtilsTest.java
+++ b/src/test/java/net/starlark/java/eval/EvalUtilsTest.java
@@ -17,6 +17,7 @@
 import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.assertThrows;
 
+import java.math.BigInteger;
 import javax.annotation.Nullable;
 import net.starlark.java.annot.StarlarkBuiltin;
 import org.junit.Test;
@@ -61,12 +62,14 @@
   @Test
   public void testDatatypeMutabilityPrimitive() throws Exception {
     assertThat(Starlark.isImmutable("foo")).isTrue();
-    assertThat(Starlark.isImmutable(3)).isTrue();
+    assertThat(Starlark.isImmutable(StarlarkInt.of(3))).isTrue();
   }
 
   @Test
   public void testDatatypeMutabilityShallow() throws Exception {
-    assertThat(Starlark.isImmutable(Tuple.of(1, 2, 3))).isTrue();
+    assertThat(
+            Starlark.isImmutable(Tuple.of(StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3))))
+        .isTrue();
 
     assertThat(Starlark.isImmutable(makeList(null))).isTrue();
     assertThat(Starlark.isImmutable(makeDict(null))).isTrue();
@@ -91,15 +94,15 @@
 
     Object[] objects = {
       "1",
-      2,
+      StarlarkInt.of(2),
       true,
       Starlark.NONE,
-      Tuple.of(1, 2, 3),
+      Tuple.of(StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3)),
       Tuple.of("1", "2", "3"),
-      StarlarkList.of(mu, 1, 2, 3),
+      StarlarkList.of(mu, StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3)),
       StarlarkList.of(mu, "1", "2", "3"),
-      Dict.of(mu, "key", 123),
-      Dict.of(mu, 123, "value"),
+      Dict.of(mu, "key", StarlarkInt.of(123)),
+      Dict.of(mu, StarlarkInt.of(123), "value"),
       myValue,
     };
 
@@ -126,10 +129,47 @@
   @Test
   public void testLen() {
     assertThat(Starlark.len("abc")).isEqualTo(3);
-    assertThat(Starlark.len(Tuple.of(1, 2, 3))).isEqualTo(3);
-    assertThat(Starlark.len(StarlarkList.of(null, 1, 2, 3))).isEqualTo(3);
-    assertThat(Starlark.len(Dict.of(null, "one", 1, "two", 2))).isEqualTo(2);
+    assertThat(Starlark.len(Tuple.of(StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3))))
+        .isEqualTo(3);
+    assertThat(
+            Starlark.len(
+                StarlarkList.of(null, StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3))))
+        .isEqualTo(3);
+    assertThat(Starlark.len(Dict.of(null, "one", StarlarkInt.of(1), "two", StarlarkInt.of(2))))
+        .isEqualTo(2);
     assertThat(Starlark.len(true)).isEqualTo(-1);
     assertThrows(IllegalArgumentException.class, () -> Starlark.len(this));
   }
+
+  @Test
+  public void testIntConstructor() throws Exception {
+    // small values are cached
+    assertThat(StarlarkInt.of(-1)).isSameInstanceAs(StarlarkInt.of(-1));
+    assertThat(StarlarkInt.of(0)).isSameInstanceAs(StarlarkInt.ZERO);
+    assertThat(StarlarkInt.of(123)).isSameInstanceAs(StarlarkInt.of(123));
+    // int32
+    assertThat(StarlarkInt.of(0).getClass().getSimpleName()).isEqualTo("Int32");
+    assertThat(StarlarkInt.of(Integer.MAX_VALUE).getClass().getSimpleName()).isEqualTo("Int32");
+    assertThat(StarlarkInt.of(Integer.MIN_VALUE).getClass().getSimpleName()).isEqualTo("Int32");
+    // int64
+    assertThat(StarlarkInt.of((long) Integer.MAX_VALUE + 1).getClass().getSimpleName())
+        .isEqualTo("Int64");
+    assertThat(StarlarkInt.of((long) Integer.MIN_VALUE - 1).getClass().getSimpleName())
+        .isEqualTo("Int64");
+    assertThat(StarlarkInt.of(Long.MAX_VALUE).getClass().getSimpleName()).isEqualTo("Int64");
+    assertThat(StarlarkInt.of(Long.MIN_VALUE).getClass().getSimpleName()).isEqualTo("Int64");
+    // big
+    assertThat(StarlarkInt.of(new BigInteger("7fffffffffffffff", 16)).getClass().getSimpleName())
+        .isEqualTo("Int64"); // (max long)
+    assertThat(StarlarkInt.of(new BigInteger("8000000000000000", 16)).getClass().getSimpleName())
+        .isEqualTo("Big");
+    assertThat(StarlarkInt.of(new BigInteger("8000000000000001", 16)).getClass().getSimpleName())
+        .isEqualTo("Big");
+    assertThat(StarlarkInt.of(new BigInteger("-7fffffffffffffff", 16)).getClass().getSimpleName())
+        .isEqualTo("Int64");
+    assertThat(StarlarkInt.of(new BigInteger("-8000000000000000", 16)).getClass().getSimpleName())
+        .isEqualTo("Int64"); // (min long)
+    assertThat(StarlarkInt.of(new BigInteger("-8000000000000001", 16)).getClass().getSimpleName())
+        .isEqualTo("Big");
+  }
 }
diff --git a/src/test/java/net/starlark/java/eval/EvaluationTest.java b/src/test/java/net/starlark/java/eval/EvaluationTest.java
index 3020e60..f1c47f8 100644
--- a/src/test/java/net/starlark/java/eval/EvaluationTest.java
+++ b/src/test/java/net/starlark/java/eval/EvaluationTest.java
@@ -170,17 +170,19 @@
         .testExpression("'%sx' % 'foo' + 'bar1'", "fooxbar1")
         .testExpression("('%sx' % 'foo') + 'bar2'", "fooxbar2")
         .testExpression("'%sx' % ('foo' + 'bar3')", "foobar3x")
-        .testExpression("123 + 456", 579)
-        .testExpression("456 - 123", 333)
-        .testExpression("8 % 3", 2)
+        .testExpression("123 + 456", StarlarkInt.of(579))
+        .testExpression("456 - 123", StarlarkInt.of(333))
+        .testExpression("8 % 3", StarlarkInt.of(2))
         .testIfErrorContains("unsupported binary operation: int % string", "3 % 'foo'")
-        .testExpression("-5", -5)
+        .testExpression("-5", StarlarkInt.of(-5))
         .testIfErrorContains("unsupported unary operation: -string", "-'foo'");
   }
 
   @Test
   public void testListExprs() throws Exception {
-    ev.new Scenario().testExactOrder("[1, 2, 3]", 1, 2, 3).testExactOrder("(1, 2, 3)", 1, 2, 3);
+    ev.new Scenario()
+        .testExactOrder("[1, 2, 3]", StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3))
+        .testExactOrder("(1, 2, 3)", StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3));
   }
 
   @Test
@@ -191,9 +193,9 @@
   @Test
   public void testConditionalExpressions() throws Exception {
     ev.new Scenario()
-        .testExpression("1 if True else 2", 1)
-        .testExpression("1 if False else 2", 2)
-        .testExpression("1 + 2 if 3 + 4 else 5 + 6", 3);
+        .testExpression("1 if True else 2", StarlarkInt.of(1))
+        .testExpression("1 if False else 2", StarlarkInt.of(2))
+        .testExpression("1 + 2 if 3 + 4 else 5 + 6", StarlarkInt.of(3));
   }
 
   @Test
@@ -226,10 +228,11 @@
           }
 
           @Override
-          public Object fastcall(StarlarkThread thread, Object[] positional, Object[] named) {
-            int sum = 0;
+          public StarlarkInt fastcall(StarlarkThread thread, Object[] positional, Object[] named)
+              throws EvalException {
+            StarlarkInt sum = StarlarkInt.of(0);
             for (Object arg : positional) {
-              sum += (Integer) arg;
+              sum = StarlarkInt.add(sum, (StarlarkInt) arg);
             }
             return sum;
           }
@@ -237,18 +240,18 @@
 
     ev.new Scenario()
         .update(sum.getName(), sum)
-        .testExpression("sum(1, 2, 3, 4, 5, 6)", 21)
+        .testExpression("sum(1, 2, 3, 4, 5, 6)", StarlarkInt.of(21))
         .testExpression("sum", sum)
-        .testExpression("sum(a=1, b=2)", 0);
+        .testExpression("sum(a=1, b=2)", StarlarkInt.of(0));
   }
 
   @Test
   public void testNotCallInt() throws Exception {
     ev.new Scenario()
         .setUp("sum = 123456")
-        .testLookup("sum", 123456)
+        .testLookup("sum", StarlarkInt.of(123456))
         .testIfExactError("'int' object is not callable", "sum(1, 2, 3, 4, 5, 6)")
-        .testExpression("sum", 123456);
+        .testExpression("sum", StarlarkInt.of(123456));
   }
 
   @Test
@@ -290,19 +293,19 @@
   @Test
   public void testModulo() throws Exception {
     ev.new Scenario()
-        .testExpression("6 % 2", 0)
-        .testExpression("6 % 4", 2)
-        .testExpression("3 % 6", 3)
-        .testExpression("7 % -4", -1)
-        .testExpression("-7 % 4", 1)
-        .testExpression("-7 % -4", -3)
+        .testExpression("6 % 2", StarlarkInt.of(0))
+        .testExpression("6 % 4", StarlarkInt.of(2))
+        .testExpression("3 % 6", StarlarkInt.of(3))
+        .testExpression("7 % -4", StarlarkInt.of(-1))
+        .testExpression("-7 % 4", StarlarkInt.of(1))
+        .testExpression("-7 % -4", StarlarkInt.of(-3))
         .testIfExactError("integer modulo by zero", "5 % 0");
   }
 
   @Test
   public void testMult() throws Exception {
     ev.new Scenario()
-        .testExpression("6 * 7", 42)
+        .testExpression("6 * 7", StarlarkInt.of(42))
         .testExpression("3 * 'ab'", "ababab")
         .testExpression("0 * 'ab'", "")
         .testExpression("'1' + '0' * 5", "100000")
@@ -318,35 +321,38 @@
   @Test
   public void testFloorDivision() throws Exception {
     ev.new Scenario()
-        .testExpression("6 // 2", 3)
-        .testExpression("6 // 4", 1)
-        .testExpression("3 // 6", 0)
-        .testExpression("7 // -2", -4)
-        .testExpression("-7 // 2", -4)
-        .testExpression("-7 // -2", 3)
-        .testExpression("2147483647 // 2", 1073741823)
+        .testExpression("6 // 2", StarlarkInt.of(3))
+        .testExpression("6 // 4", StarlarkInt.of(1))
+        .testExpression("3 // 6", StarlarkInt.of(0))
+        .testExpression("7 // -2", StarlarkInt.of(-4))
+        .testExpression("-7 // 2", StarlarkInt.of(-4))
+        .testExpression("-7 // -2", StarlarkInt.of(3))
+        .testExpression("2147483647 // 2", StarlarkInt.of(1073741823))
         .testIfErrorContains("unsupported binary operation: string // int", "'str' // 2")
         .testIfExactError("integer division by zero", "5 // 0");
   }
 
   @Test
-  public void testCheckedArithmetic() throws Exception {
+  public void testArithmeticDoesNotOverflow() throws Exception {
     ev.new Scenario()
-        .testIfErrorContains("integer overflow", "2000000000 + 2000000000")
-        .testIfErrorContains("integer overflow", "1234567890 * 987654321")
-        .testIfErrorContains("integer overflow", "- 2000000000 - 2000000000")
+        .testEval("2000000000 + 2000000000", "1000000000 + 1000000000 + 1000000000 + 1000000000")
+        .testExpression("1234567890 * 987654321", StarlarkInt.of(1219326311126352690L))
+        .testExpression(
+            "1234567890 * 987654321 * 987654321",
+            StarlarkInt.multiply(StarlarkInt.of(1219326311126352690L), StarlarkInt.of(987654321)))
+        .testEval("- 2000000000 - 2000000000", "-1000000000 - 1000000000 - 1000000000 - 1000000000")
 
         // literal 2147483648 is not allowed, so we compute it
         .setUp("minint = - 2147483647 - 1")
-        .testIfErrorContains("integer overflow", "-minint");
+        .testEval("-minint", "2147483647+1");
   }
 
   @Test
   public void testOperatorPrecedence() throws Exception {
     ev.new Scenario()
-        .testExpression("2 + 3 * 4", 14)
-        .testExpression("2 + 3 // 4", 2)
-        .testExpression("2 * 3 + 4 // -2", 4);
+        .testExpression("2 + 3 * 4", StarlarkInt.of(14))
+        .testExpression("2 + 3 // 4", StarlarkInt.of(2))
+        .testExpression("2 * 3 + 4 // -2", StarlarkInt.of(4));
   }
 
   @Test
@@ -357,22 +363,38 @@
   @Test
   public void testConcatLists() throws Exception {
     ev.new Scenario()
-        .testExactOrder("[1,2] + [3,4]", 1, 2, 3, 4)
-        .testExactOrder("(1,2)", 1, 2)
-        .testExactOrder("(1,2) + (3,4)", 1, 2, 3, 4);
+        .testExactOrder(
+            "[1,2] + [3,4]",
+            StarlarkInt.of(1),
+            StarlarkInt.of(2),
+            StarlarkInt.of(3),
+            StarlarkInt.of(4))
+        .testExactOrder("(1,2)", StarlarkInt.of(1), StarlarkInt.of(2))
+        .testExactOrder(
+            "(1,2) + (3,4)",
+            StarlarkInt.of(1),
+            StarlarkInt.of(2),
+            StarlarkInt.of(3),
+            StarlarkInt.of(4));
 
     // TODO(fwe): cannot be handled by current testing suite
     // list
     Object x = ev.eval("[1,2] + [3,4]");
-    assertThat((Iterable<?>) x).containsExactly(1, 2, 3, 4).inOrder();
+    assertThat((Iterable<?>) x)
+        .containsExactly(StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3), StarlarkInt.of(4))
+        .inOrder();
     assertThat(x).isInstanceOf(StarlarkList.class);
     assertThat(Starlark.isImmutable(x)).isFalse();
 
     // tuple
     x = ev.eval("(1,2) + (3,4)");
-    assertThat((Iterable<?>) x).containsExactly(1, 2, 3, 4).inOrder();
+    assertThat((Iterable<?>) x)
+        .containsExactly(StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3), StarlarkInt.of(4))
+        .inOrder();
     assertThat(x).isInstanceOf(Tuple.class);
-    assertThat(x).isEqualTo(Tuple.of(1, 2, 3, 4));
+    assertThat(x)
+        .isEqualTo(
+            Tuple.of(StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3), StarlarkInt.of(4)));
     assertThat(Starlark.isImmutable(x)).isTrue();
 
     ev.checkEvalError("unsupported binary operation: tuple + list", "(1,2) + [3,4]");
@@ -416,15 +438,20 @@
             "bar/wiz.cc",
             "bar/quux.java",
             "bar/quux.cc")
-        .testExactOrder("[i for i in (1, 2)]", 1, 2)
-        .testExactOrder("[i for i in [2, 3] or [1, 2]]", 2, 3);
+        .testExactOrder("[i for i in (1, 2)]", StarlarkInt.of(1), StarlarkInt.of(2))
+        .testExactOrder("[i for i in [2, 3] or [1, 2]]", StarlarkInt.of(2), StarlarkInt.of(3));
   }
 
   @Test
   public void testNestedListComprehensions() throws Exception {
     ev.new Scenario()
         .setUp("li = [[1, 2], [3, 4]]")
-        .testExactOrder("[j for i in li for j in i]", 1, 2, 3, 4);
+        .testExactOrder(
+            "[j for i in li for j in i]",
+            StarlarkInt.of(1),
+            StarlarkInt.of(2),
+            StarlarkInt.of(3),
+            StarlarkInt.of(4));
     ev.new Scenario()
         .setUp("input = [['abc'], ['def', 'ghi']]\n")
         .testExactOrder(
@@ -566,8 +593,8 @@
   public void testTupleDestructuring() throws Exception {
     ev.new Scenario()
         .setUp("a, b = 1, 2")
-        .testLookup("a", 1)
-        .testLookup("b", 2)
+        .testLookup("a", StarlarkInt.of(1))
+        .testLookup("b", StarlarkInt.of(2))
         .setUp("c, d = {'key1':2, 'key2':3}")
         .testLookup("c", "key1")
         .testLookup("d", "key2");
@@ -575,20 +602,20 @@
 
   @Test
   public void testSingleTuple() throws Exception {
-    ev.new Scenario().setUp("(a,) = [1]").testLookup("a", 1);
+    ev.new Scenario().setUp("(a,) = [1]").testLookup("a", StarlarkInt.of(1));
   }
 
   @Test
   public void testHeterogeneousDict() throws Exception {
     ev.new Scenario()
         .setUp("d = {'str': 1, 2: 3}", "a = d['str']", "b = d[2]")
-        .testLookup("a", 1)
-        .testLookup("b", 3);
+        .testLookup("a", StarlarkInt.of(1))
+        .testLookup("b", StarlarkInt.of(3));
   }
 
   @Test
   public void testAccessDictWithATupleKey() throws Exception {
-    ev.new Scenario().setUp("x = {(1, 2): 3}[1, 2]").testLookup("x", 3);
+    ev.new Scenario().setUp("x = {(1, 2): 3}[1, 2]").testLookup("x", StarlarkInt.of(3));
   }
 
   @Test
@@ -602,26 +629,29 @@
   public void testRecursiveTupleDestructuring() throws Exception {
     ev.new Scenario()
         .setUp("((a, b), (c, d)) = [(1, 2), (3, 4)]")
-        .testLookup("a", 1)
-        .testLookup("b", 2)
-        .testLookup("c", 3)
-        .testLookup("d", 4);
+        .testLookup("a", StarlarkInt.of(1))
+        .testLookup("b", StarlarkInt.of(2))
+        .testLookup("c", StarlarkInt.of(3))
+        .testLookup("d", StarlarkInt.of(4));
   }
 
   @Test
   public void testListComprehensionAtTopLevel() throws Exception {
     // It is allowed to have a loop variable with the same name as a global variable.
     ev.new Scenario()
-        .update("x", 42)
+        .update("x", StarlarkInt.of(42))
         .setUp("y = [x + 1 for x in [1,2,3]]")
-        .testExactOrder("y", 2, 3, 4);
+        .testExactOrder("y", StarlarkInt.of(2), StarlarkInt.of(3), StarlarkInt.of(4));
   }
 
   @Test
   public void testDictComprehensions() throws Exception {
     ev.new Scenario()
         .testExpression("{a : a for a in []}", Collections.emptyMap())
-        .testExpression("{b : b for b in [1, 2]}", ImmutableMap.of(1, 1, 2, 2))
+        .testExpression(
+            "{b : b for b in [1, 2]}",
+            ImmutableMap.of(
+                StarlarkInt.of(1), StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(2)))
         .testExpression(
             "{c : 'v_' + c for c in ['a', 'b']}", ImmutableMap.of("a", "v_a", "b", "v_b"))
         .testExpression(
@@ -629,7 +659,9 @@
         .testExpression(
             "{'k_' + e : 'v_' + e for e in ['a', 'b']}",
             ImmutableMap.of("k_a", "v_a", "k_b", "v_b"))
-        .testExpression("{x+y : x*y for x, y in [[2, 3]]}", ImmutableMap.of(5, 6));
+        .testExpression(
+            "{x+y : x*y for x, y in [[2, 3]]}",
+            ImmutableMap.of(StarlarkInt.of(5), StarlarkInt.of(6)));
   }
 
   @Test
@@ -642,13 +674,24 @@
     ev.new Scenario()
         .testExpression(
             "{x : x * y for x in range(1, 10) if x % 2 == 0 for y in range(1, 10) if y == x}",
-            ImmutableMap.of(2, 4, 4, 16, 6, 36, 8, 64));
+            ImmutableMap.of(
+                StarlarkInt.of(2),
+                StarlarkInt.of(4),
+                StarlarkInt.of(4),
+                StarlarkInt.of(16),
+                StarlarkInt.of(6),
+                StarlarkInt.of(36),
+                StarlarkInt.of(8),
+                StarlarkInt.of(64)));
   }
 
   @Test
   public void testDictComprehensions_multipleKey() throws Exception {
     ev.new Scenario()
-        .testExpression("{x : x for x in [1, 2, 1]}", ImmutableMap.of(1, 1, 2, 2))
+        .testExpression(
+            "{x : x for x in [1, 2, 1]}",
+            ImmutableMap.of(
+                StarlarkInt.of(1), StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(2)))
         .testExpression(
             "{y : y for y in ['ab', 'c', 'a' + 'b']}", ImmutableMap.of("ab", "ab", "c", "c"));
   }
@@ -656,45 +699,44 @@
   @Test
   public void testListConcatenation() throws Exception {
     ev.new Scenario()
-        .testExpression("[1, 2] + [3, 4]", StarlarkList.of(null, 1, 2, 3, 4))
-        .testExpression("(1, 2) + (3, 4)", Tuple.of(1, 2, 3, 4))
+        .testEval("[1, 2] + [3, 4]", "[1, 2, 3, 4]")
+        .testEval("(1, 2) + (3, 4)", "(1, 2, 3, 4)")
         .testIfExactError("unsupported binary operation: list + tuple", "[1, 2] + (3, 4)")
         .testIfExactError("unsupported binary operation: tuple + list", "(1, 2) + [3, 4]");
   }
 
   @Test
   public void testListMultiply() throws Exception {
-    Mutability mu = Mutability.create("test");
     ev.new Scenario()
-        .testExpression("[1, 2, 3] * 1", StarlarkList.of(mu, 1, 2, 3))
-        .testExpression("[1, 2] * 2", StarlarkList.of(mu, 1, 2, 1, 2))
-        .testExpression("[1, 2] * 3", StarlarkList.of(mu, 1, 2, 1, 2, 1, 2))
-        .testExpression("[1, 2] * 4", StarlarkList.of(mu, 1, 2, 1, 2, 1, 2, 1, 2))
-        .testExpression("[8] * 5", StarlarkList.of(mu, 8, 8, 8, 8, 8))
-        .testExpression("[    ] * 10", StarlarkList.empty())
-        .testExpression("[1, 2] * 0", StarlarkList.empty())
-        .testExpression("[1, 2] * -4", StarlarkList.empty())
-        .testExpression("2 * [1, 2]", StarlarkList.of(mu, 1, 2, 1, 2))
-        .testExpression("10 * []", StarlarkList.empty())
-        .testExpression("0 * [1, 2]", StarlarkList.empty())
-        .testExpression("-4 * [1, 2]", StarlarkList.empty());
+        .testEval("[1, 2, 3] * 1", "[1, 2, 3]")
+        .testEval("[1, 2] * 2", "[1, 2, 1, 2]")
+        .testEval("[1, 2] * 3", "[1, 2, 1, 2, 1, 2]")
+        .testEval("[1, 2] * 4", "[1, 2, 1, 2, 1, 2, 1, 2]")
+        .testEval("[8] * 5", "[8, 8, 8, 8, 8]")
+        .testEval("[    ] * 10", "[]")
+        .testEval("[1, 2] * 0", "[]")
+        .testEval("[1, 2] * -4", "[]")
+        .testEval("2 * [1, 2]", "[1, 2, 1, 2]")
+        .testEval("10 * []", "[]")
+        .testEval("0 * [1, 2]", "[]")
+        .testEval("-4 * [1, 2]", "[]");
   }
 
   @Test
   public void testTupleMultiply() throws Exception {
     ev.new Scenario()
-        .testExpression("(1, 2, 3) * 1", Tuple.of(1, 2, 3))
-        .testExpression("(1, 2) * 2", Tuple.of(1, 2, 1, 2))
-        .testExpression("(1, 2) * 3", Tuple.of(1, 2, 1, 2, 1, 2))
-        .testExpression("(1, 2) * 4", Tuple.of(1, 2, 1, 2, 1, 2, 1, 2))
-        .testExpression("(8,) * 5", Tuple.of(8, 8, 8, 8, 8))
-        .testExpression("(    ) * 10", Tuple.empty())
-        .testExpression("(1, 2) * 0", Tuple.empty())
-        .testExpression("(1, 2) * -4", Tuple.empty())
-        .testExpression("2 * (1, 2)", Tuple.of(1, 2, 1, 2))
-        .testExpression("10 * ()", Tuple.empty())
-        .testExpression("0 * (1, 2)", Tuple.empty())
-        .testExpression("-4 * (1, 2)", Tuple.empty());
+        .testEval("(1, 2, 3) * 1", "(1, 2, 3)")
+        .testEval("(1, 2) * 2", "(1, 2, 1, 2)")
+        .testEval("(1, 2) * 3", "(1, 2, 1, 2, 1, 2)")
+        .testEval("(1, 2) * 4", "(1, 2, 1, 2, 1, 2, 1, 2)")
+        .testEval("(8,) * 5", "(8, 8, 8, 8, 8)")
+        .testEval("(    ) * 10", "()")
+        .testEval("(1, 2) * 0", "()")
+        .testEval("(1, 2) * -4", "()")
+        .testEval("2 * (1, 2)", "(1, 2, 1, 2)")
+        .testEval("10 * ()", "()")
+        .testEval("0 * (1, 2)", "()")
+        .testEval("-4 * (1, 2)", "()");
   }
 
   @Test
@@ -809,7 +851,7 @@
 
   @Test
   public void testInCompositeForPrecedence() throws Exception {
-    ev.new Scenario().testExpression("not 'a' in ['a'] or 0", 0);
+    ev.new Scenario().testExpression("not 'a' in ['a'] or 0", StarlarkInt.of(0));
   }
 
   private static StarlarkValue createObjWithStr() {
@@ -913,6 +955,15 @@
       Starlark.execFile(input, FileOptions.DEFAULT, module, thread);
     }
     assertThat(module.getGlobal("x"))
-        .isEqualTo(StarlarkList.of(/*mutability=*/ null, 1, 2, "foo", 4, 1, 2, "foo1"));
+        .isEqualTo(
+            StarlarkList.of(
+                /*mutability=*/ null,
+                StarlarkInt.of(1),
+                StarlarkInt.of(2),
+                "foo",
+                StarlarkInt.of(4),
+                StarlarkInt.of(1),
+                StarlarkInt.of(2),
+                "foo1"));
   }
 }
diff --git a/src/test/java/net/starlark/java/eval/FunctionTest.java b/src/test/java/net/starlark/java/eval/FunctionTest.java
index 6aeb4c7..519cb52 100644
--- a/src/test/java/net/starlark/java/eval/FunctionTest.java
+++ b/src/test/java/net/starlark/java/eval/FunctionTest.java
@@ -38,7 +38,9 @@
         .inOrder();
     assertThat(f.hasVarargs()).isTrue();
     assertThat(f.hasKwargs()).isTrue();
-    assertThat(getDefaults(f)).containsExactly(null, 1, null, 2, null, null).inOrder();
+    assertThat(getDefaults(f))
+        .containsExactly(null, StarlarkInt.of(1), null, StarlarkInt.of(2), null, null)
+        .inOrder();
 
     // same, sans varargs
     ev.exec("def g(a, b=1, *, c, d=2, **kwargs): pass");
@@ -46,7 +48,9 @@
     assertThat(g.getParameterNames()).containsExactly("a", "b", "c", "d", "kwargs").inOrder();
     assertThat(g.hasVarargs()).isFalse();
     assertThat(g.hasKwargs()).isTrue();
-    assertThat(getDefaults(g)).containsExactly(null, 1, null, 2, null).inOrder();
+    assertThat(getDefaults(g))
+        .containsExactly(null, StarlarkInt.of(1), null, StarlarkInt.of(2), null)
+        .inOrder();
   }
 
   private static List<Object> getDefaults(StarlarkFunction fn) {
@@ -66,7 +70,7 @@
         "  outer_func(a)",
         "func(1)",
         "func(2)");
-    assertThat(params).containsExactly(1, 2).inOrder();
+    assertThat(params).containsExactly(StarlarkInt.of(1), StarlarkInt.of(2)).inOrder();
   }
 
   private void createOuterFunction(final List<Object> params) throws Exception {
@@ -90,12 +94,12 @@
 
   @Test
   public void testFunctionDefNoEffectOutsideScope() throws Exception {
-    ev.update("a", 1);
+    ev.update("a", StarlarkInt.of(1));
     ev.exec(
         "def func():", //
         "  a = 2",
         "func()\n");
-    assertThat(ev.lookup("a")).isEqualTo(1);
+    assertThat(ev.lookup("a")).isEqualTo(StarlarkInt.of(1));
   }
 
   @Test
@@ -106,7 +110,7 @@
         "  b = a",
         "  return b",
         "c = func()\n");
-    assertThat(ev.lookup("c")).isEqualTo(1);
+    assertThat(ev.lookup("c")).isEqualTo(StarlarkInt.of(1));
   }
 
   @Test
@@ -118,7 +122,7 @@
         "  b = a",
         "  return b",
         "c = func()\n");
-    assertThat(ev.lookup("c")).isEqualTo(2);
+    assertThat(ev.lookup("c")).isEqualTo(StarlarkInt.of(2));
   }
 
   @Test
@@ -156,14 +160,16 @@
         "  a = 3",
         "  return b",
         "c = func()\n");
-    assertThat(ev.lookup("c")).isEqualTo(2);
+    assertThat(ev.lookup("c")).isEqualTo(StarlarkInt.of(2));
   }
 
   @SuppressWarnings("unchecked")
   @Test
   public void testStarlarkGlobalComprehensionIsAllowed() throws Exception {
     ev.exec("a = [i for i in [1, 2, 3]]\n");
-    assertThat((Iterable<Object>) ev.lookup("a")).containsExactly(1, 2, 3).inOrder();
+    assertThat((Iterable<Object>) ev.lookup("a"))
+        .containsExactly(StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3))
+        .inOrder();
   }
 
   @Test
@@ -172,7 +178,7 @@
         "def func():", //
         "  return 2",
         "b = func()\n");
-    assertThat(ev.lookup("b")).isEqualTo(2);
+    assertThat(ev.lookup("b")).isEqualTo(StarlarkInt.of(2));
   }
 
   @Test
@@ -182,7 +188,7 @@
         "  for i in [1, 2, 3, 4, 5]:",
         "    return i",
         "b = func()\n");
-    assertThat(ev.lookup("b")).isEqualTo(1);
+    assertThat(ev.lookup("b")).isEqualTo(StarlarkInt.of(1));
   }
 
   @Test
@@ -195,8 +201,8 @@
         "  return b",
         "c = func(0)",
         "d = func(1)\n");
-    assertThat(ev.lookup("c")).isEqualTo(1);
-    assertThat(ev.lookup("d")).isEqualTo(2);
+    assertThat(ev.lookup("c")).isEqualTo(StarlarkInt.of(1));
+    assertThat(ev.lookup("d")).isEqualTo(StarlarkInt.of(2));
   }
 
   @Test
@@ -210,7 +216,7 @@
         "  func2(b)",
         "func1(1)",
         "func1(2)\n");
-    assertThat(params).containsExactly(1, 2).inOrder();
+    assertThat(params).containsExactly(StarlarkInt.of(1), StarlarkInt.of(2)).inOrder();
   }
 
   @Test
@@ -222,7 +228,7 @@
         "def func1():",
         "  return func2()",
         "b = func1()\n");
-    assertThat(ev.lookup("b")).isEqualTo(1);
+    assertThat(ev.lookup("b")).isEqualTo(StarlarkInt.of(1));
   }
 
   @Test
@@ -235,7 +241,7 @@
         "  dummy = a",
         "  return func2(2)",
         "b = func1()\n");
-    assertThat(ev.lookup("b")).isEqualTo(0);
+    assertThat(ev.lookup("b")).isEqualTo(StarlarkInt.of(0));
   }
 
   @Test
@@ -252,7 +258,7 @@
         "def func(): return {'a' : 1}", //
         "d = func()",
         "a = d['a']\n");
-    assertThat(ev.lookup("a")).isEqualTo(1);
+    assertThat(ev.lookup("a")).isEqualTo(StarlarkInt.of(1));
   }
 
   @Test
@@ -261,7 +267,7 @@
         "def func(): return [1, 2, 3]", //
         "d = func()",
         "a = d[1]\n");
-    assertThat(ev.lookup("a")).isEqualTo(2);
+    assertThat(ev.lookup("a")).isEqualTo(StarlarkInt.of(2));
   }
 
   @Test
@@ -271,7 +277,7 @@
         "  return a + 1",
         "alias = func",
         "r = alias(1)");
-    assertThat(ev.lookup("r")).isEqualTo(2);
+    assertThat(ev.lookup("r")).isEqualTo(StarlarkInt.of(2));
   }
 
   @Test
@@ -280,7 +286,7 @@
         "def func(a, b, c):", //
         "  return a + b + c",
         "v = func(1, c = 2, b = 3)");
-    assertThat(ev.lookup("v")).isEqualTo(6);
+    assertThat(ev.lookup("v")).isEqualTo(StarlarkInt.of(6));
   }
 
   private String functionWithOptionalArgs() {
@@ -448,7 +454,7 @@
         "  a = 3",
         "  return foo()",
         "v = bar()\n");
-    assertThat(ev.lookup("v")).isEqualTo(2);
+    assertThat(ev.lookup("v")).isEqualTo(StarlarkInt.of(2));
   }
 
   @Test
diff --git a/src/test/java/net/starlark/java/eval/MethodLibraryTest.java b/src/test/java/net/starlark/java/eval/MethodLibraryTest.java
index ede15a6..775be58 100644
--- a/src/test/java/net/starlark/java/eval/MethodLibraryTest.java
+++ b/src/test/java/net/starlark/java/eval/MethodLibraryTest.java
@@ -312,13 +312,13 @@
   public void testDictionaryAccess() throws Exception {
     ev.new Scenario()
         .testEval("{1: ['foo']}[1]", "['foo']")
-        .testExpression("{'4': 8}['4']", 8)
+        .testExpression("{'4': 8}['4']", StarlarkInt.of(8))
         .testExpression("{'a': 'aa', 'b': 'bb', 'c': 'cc'}['b']", "bb");
   }
 
   @Test
   public void testDictionaryVariableAccess() throws Exception {
-    ev.new Scenario().setUp("d = {'a' : 1}", "a = d['a']").testLookup("a", 1);
+    ev.new Scenario().setUp("d = {'a' : 1}", "a = d['a']").testLookup("a", StarlarkInt.of(1));
   }
 
   @Test
@@ -482,12 +482,12 @@
   @Test
   public void testListIndexMethod() throws Exception {
     ev.new Scenario()
-        .testExpression("['a', 'b', 'c'].index('a')", 0)
-        .testExpression("['a', 'b', 'c'].index('b')", 1)
-        .testExpression("['a', 'b', 'c'].index('c')", 2)
-        .testExpression("[2, 4, 6].index(4)", 1)
-        .testExpression("[2, 4, 6].index(4)", 1)
-        .testExpression("[0, 1, [1]].index([1])", 2)
+        .testExpression("['a', 'b', 'c'].index('a')", StarlarkInt.of(0))
+        .testExpression("['a', 'b', 'c'].index('b')", StarlarkInt.of(1))
+        .testExpression("['a', 'b', 'c'].index('c')", StarlarkInt.of(2))
+        .testExpression("[2, 4, 6].index(4)", StarlarkInt.of(1))
+        .testExpression("[2, 4, 6].index(4)", StarlarkInt.of(1))
+        .testExpression("[0, 1, [1]].index([1])", StarlarkInt.of(2))
         .testIfErrorContains("item \"a\" not found in list", "[1, 2].index('a')")
         .testIfErrorContains("item 0 not found in list", "[].index(0)");
   }
@@ -496,8 +496,8 @@
   public void testHash() throws Exception {
     // We specify the same string hashing algorithm as String.hashCode().
     ev.new Scenario()
-        .testExpression("hash('starlark')", "starlark".hashCode())
-        .testExpression("hash('google')", "google".hashCode())
+        .testExpression("hash('starlark')", StarlarkInt.of("starlark".hashCode()))
+        .testExpression("hash('google')", StarlarkInt.of("google".hashCode()))
         .testIfErrorContains(
             "in call to hash(), parameter 'value' got value of type 'NoneType', want 'string'",
             "hash(None)");
@@ -507,7 +507,7 @@
   public void testRangeType() throws Exception {
     ev.new Scenario()
         .setUp("a = range(3)")
-        .testExpression("len(a)", 3)
+        .testExpression("len(a)", StarlarkInt.of(3))
         .testExpression("str(a)", "range(0, 3)")
         .testExpression("str(range(1,2,3))", "range(1, 2, 3)")
         .testExpression("repr(a)", "range(0, 3)")
@@ -529,11 +529,11 @@
         .testExpression("str(list(range(5, 0, -1)))", "[5, 4, 3, 2, 1]")
         .testExpression("str(list(range(5, 0, -10)))", "[5]")
         .testExpression("str(list(range(0, -3, -2)))", "[0, -2]")
-        .testExpression("range(3)[-1]", 2)
+        .testExpression("range(3)[-1]", StarlarkInt.of(2))
         .testIfErrorContains(
             "index out of range (index is 3, but sequence has 3 elements)", "range(3)[3]")
         .testExpression("str(range(5)[1:])", "range(1, 5)")
-        .testExpression("len(range(5)[1:])", 4)
+        .testExpression("len(range(5)[1:])", StarlarkInt.of(4))
         .testExpression("str(range(5)[:2])", "range(0, 2)")
         .testExpression("str(range(10)[1:9:2])", "range(1, 9, 2)")
         .testExpression("str(list(range(10)[1:9:2]))", "[1, 3, 5, 7]")
@@ -600,17 +600,17 @@
 
   @Test
   public void testLenOnString() throws Exception {
-    ev.new Scenario().testExpression("len('abc')", 3);
+    ev.new Scenario().testExpression("len('abc')", StarlarkInt.of(3));
   }
 
   @Test
   public void testLenOnList() throws Exception {
-    ev.new Scenario().testExpression("len([1,2,3])", 3);
+    ev.new Scenario().testExpression("len([1,2,3])", StarlarkInt.of(3));
   }
 
   @Test
   public void testLenOnDict() throws Exception {
-    ev.new Scenario().testExpression("len({'a' : 1, 'b' : 2})", 2);
+    ev.new Scenario().testExpression("len({'a' : 1, 'b' : 2})", StarlarkInt.of(2));
   }
 
   @Test
diff --git a/src/test/java/net/starlark/java/eval/PrinterTest.java b/src/test/java/net/starlark/java/eval/PrinterTest.java
index 4af6b61..e5accf4 100644
--- a/src/test/java/net/starlark/java/eval/PrinterTest.java
+++ b/src/test/java/net/starlark/java/eval/PrinterTest.java
@@ -85,10 +85,15 @@
 
   @Test
   public void testFormatPositional() throws Exception {
-    assertThat(Starlark.formatWithList("%s %d", Tuple.of("foo", 3))).isEqualTo("foo 3");
-    assertThat(Starlark.format("%s %d", "foo", 3)).isEqualTo("foo 3");
+    assertThat(Starlark.formatWithList("%s %d", Tuple.of("foo", StarlarkInt.of(3))))
+        .isEqualTo("foo 3");
+    assertThat(Starlark.format("%s %d", "foo", StarlarkInt.of(3))).isEqualTo("foo 3");
 
-    assertThat(Starlark.format("%s %s %s", 1, null, 3)).isEqualTo("1 null 3");
+    // %d allows Integer or StarlarkInt
+    assertThat(Starlark.format("%d %d", StarlarkInt.of(123), 456)).isEqualTo("123 456");
+
+    assertThat(Starlark.format("%s %s %s", StarlarkInt.of(1), null, StarlarkInt.of(3)))
+        .isEqualTo("1 null 3");
 
     // Note: formatToString doesn't perform scalar x -> (x) conversion;
     // The %-operator is responsible for that.
@@ -102,11 +107,19 @@
         "%%s", "foo");
     checkFormatPositionalFails("unsupported format character \" \" at index 1 in \"% %s\"",
         "% %s", "foo");
-    assertThat(Starlark.format("%s", StarlarkList.of(null, 1, 2, 3))).isEqualTo("[1, 2, 3]");
-    assertThat(Starlark.format("%s", Tuple.of(1, 2, 3))).isEqualTo("(1, 2, 3)");
+    assertThat(
+            Starlark.format(
+                "%s",
+                StarlarkList.of(null, StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3))))
+        .isEqualTo("[1, 2, 3]");
+    assertThat(
+            Starlark.format(
+                "%s", Tuple.of(StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3))))
+        .isEqualTo("(1, 2, 3)");
     assertThat(Starlark.format("%s", StarlarkList.of(null))).isEqualTo("[]");
     assertThat(Starlark.format("%s", Tuple.of())).isEqualTo("()");
-    assertThat(Starlark.format("%% %d %r %s", 1, "2", "3")).isEqualTo("% 1 \"2\" 3");
+    assertThat(Starlark.format("%% %d %r %s", StarlarkInt.of(1), "2", "3"))
+        .isEqualTo("% 1 \"2\" 3");
 
     checkFormatPositionalFails(
         "invalid argument \"1\" for format pattern %d",
diff --git a/src/test/java/net/starlark/java/eval/ScriptTest.java b/src/test/java/net/starlark/java/eval/ScriptTest.java
index 8334c5b..0cce2e6 100644
--- a/src/test/java/net/starlark/java/eval/ScriptTest.java
+++ b/src/test/java/net/starlark/java/eval/ScriptTest.java
@@ -147,6 +147,10 @@
         } catch (SyntaxError.Exception ex) {
           // parser/resolver errors
           for (SyntaxError err : ex.errors()) {
+            // TODO(adonovan): don't allow expectations to match static errors;
+            // they should be a different test suite. It is dangerous to mix
+            // them in a chunk otherwise the presence of a static error causes
+            // the program not to run the dynamic assertions.
             if (!expected(expectations, err.message())) {
               System.err.println(err); // includes location
               ok = false;
diff --git a/src/test/java/net/starlark/java/eval/StarlarkEvaluationTest.java b/src/test/java/net/starlark/java/eval/StarlarkEvaluationTest.java
index 3fd4160..d8e121b 100644
--- a/src/test/java/net/starlark/java/eval/StarlarkEvaluationTest.java
+++ b/src/test/java/net/starlark/java/eval/StarlarkEvaluationTest.java
@@ -454,6 +454,24 @@
       throw new InternalError("buggy code");
     }
 
+    @StarlarkMethod(
+        name = "int_conversion",
+        doc = "test implicit StarlarkInt to Integer conversion",
+        parameters = {
+          @Param(name = "a", type = Integer.class),
+          @Param(
+              name = "b",
+              allowedTypes = {
+                @ParamType(type = String.class),
+                @ParamType(type = Integer.class),
+              }),
+          @Param(name = "c"),
+          @Param(name = "d"),
+        })
+    public String intConversion(Object a, Object b, Integer c, Object d) {
+      return String.format("(%s, %s, %s, %s)", a, b, c, d);
+    }
+
     @Override
     public String toString() {
       return "<mock>";
@@ -526,14 +544,14 @@
   public void testSimpleIf() throws Exception {
     ev.new Scenario()
         .setUp("def foo():", "  a = 0", "  x = 0", "  if x: a = 5", "  return a", "a = foo()")
-        .testLookup("a", 0);
+        .testLookup("a", StarlarkInt.of(0));
   }
 
   @Test
   public void testIfPass() throws Exception {
     ev.new Scenario()
         .setUp("def foo():", "  a = 1", "  x = True", "  if x: pass", "  return a", "a = foo()")
-        .testLookup("a", 1);
+        .testLookup("a", StarlarkInt.of(1));
   }
 
   @Test
@@ -558,7 +576,7 @@
             "    b = 3",
             "  return a + b",
             "x = " + fun + "()")
-        .testLookup("x", expected);
+        .testLookup("x", StarlarkInt.of(expected));
   }
 
   @Test
@@ -578,7 +596,7 @@
             "    else: a = 3",
             "  return a",
             "z = " + fun + "()")
-        .testLookup("z", expected);
+        .testLookup("z", StarlarkInt.of(expected));
   }
 
   @Test
@@ -609,7 +627,7 @@
             "  else:",
             "    return 3",
             "v = foo()")
-        .testLookup("v", v);
+        .testLookup("v", StarlarkInt.of(v));
   }
 
   @Test
@@ -848,7 +866,9 @@
         "    hit = 1",
         "  return [s, hit]",
         "x = foo()");
-    assertThat((Iterable<Object>) ev.lookup("x")).containsExactly(expected, 0).inOrder();
+    assertThat((Iterable<Object>) ev.lookup("x"))
+        .containsExactly(StarlarkInt.of(expected), StarlarkInt.of(0))
+        .inOrder();
   }
 
   @Test
@@ -873,7 +893,7 @@
         "       s = s + 1",
         "   return s",
         "x = foo()");
-    assertThat(ev.lookup("x")).isEqualTo(expected);
+    assertThat(ev.lookup("x")).isEqualTo(StarlarkInt.of(expected));
   }
 
   private void flowFromNestedBlocks(String statement, int expected) throws Exception {
@@ -888,7 +908,7 @@
         "       s = s + 1",
         "   return s",
         "y = foo2()");
-    assertThat(ev.lookup("y")).isEqualTo(expected);
+    assertThat(ev.lookup("y")).isEqualTo(StarlarkInt.of(expected));
   }
 
   @Test
@@ -924,7 +944,10 @@
         "   return [outer, first, second]",
         "x = foo()");
     assertThat((Iterable<Object>) ev.lookup("x"))
-        .containsExactly(outerExpected, firstExpected, secondExpected)
+        .containsExactly(
+            StarlarkInt.of(outerExpected),
+            StarlarkInt.of(firstExpected),
+            StarlarkInt.of(secondExpected))
         .inOrder();
   }
 
@@ -970,7 +993,7 @@
   public void testNoneAssignment() throws Exception {
     ev.new Scenario()
         .setUp("def foo(x=None):", "  x = 1", "  x = None", "  return 2", "s = foo()")
-        .testLookup("s", 2);
+        .testLookup("s", StarlarkInt.of(2));
   }
 
   @Test
@@ -1479,7 +1502,7 @@
   public void testAugmentedAssignment() throws Exception {
     ev.new Scenario()
         .setUp("def f1(x):", "  x += 1", "  return x", "", "foo = f1(41)")
-        .testLookup("foo", 42);
+        .testLookup("foo", StarlarkInt.of(42));
   }
 
   @Test
@@ -1495,7 +1518,7 @@
             "  return value",
             "",
             "f()[1] += 1") // `f()` should be called only once here
-        .testLookup("counter", StarlarkList.of(null, 1));
+        .testLookup("counter", StarlarkList.of(null, StarlarkInt.of(1)));
 
     // Check key position.
     ev.new Scenario()
@@ -1508,7 +1531,7 @@
             "  return 1",
             "",
             "value[f()] += 1") // `f()` should be called only once here
-        .testLookup("counter", StarlarkList.of(null, 1));
+        .testLookup("counter", StarlarkList.of(null, StarlarkInt.of(1)));
   }
 
   @Test
@@ -1607,7 +1630,12 @@
             "  t2 += (3, 4)",
             "  return t1, t2",
             "tuples = func()")
-        .testLookup("tuples", Tuple.of(Tuple.of(1, 2), Tuple.of(1, 2, 3, 4)));
+        .testLookup(
+            "tuples",
+            Tuple.of(
+                Tuple.of(StarlarkInt.of(1), StarlarkInt.of(2)),
+                Tuple.of(
+                    StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3), StarlarkInt.of(4))));
   }
 
   @Test
@@ -1627,7 +1655,7 @@
   public void testDictAssignmentAsLValue() throws Exception {
     ev.new Scenario()
         .setUp("def func():", "  d = {'a' : 1}", "  d['b'] = 2", "  return d", "d = func()")
-        .testLookup("d", ImmutableMap.of("a", 1, "b", 2));
+        .testLookup("d", ImmutableMap.of("a", StarlarkInt.of(1), "b", StarlarkInt.of(2)));
   }
 
   @Test
@@ -1640,7 +1668,9 @@
             "  e['d']['b'] = 2",
             "  return e",
             "e = func()")
-        .testLookup("e", ImmutableMap.of("d", ImmutableMap.of("a", 1, "b", 2)));
+        .testLookup(
+            "e",
+            ImmutableMap.of("d", ImmutableMap.of("a", StarlarkInt.of(1), "b", StarlarkInt.of(2))));
   }
 
   @Test
@@ -1674,42 +1704,47 @@
     ev.new Scenario()
         .setUp(
             "def func():", "  d = {'a' : 1}", "  d['b'], d['c'] = 2, 3", "  return d", "d = func()")
-        .testLookup("d", ImmutableMap.of("a", 1, "b", 2, "c", 3));
+        .testLookup(
+            "d",
+            ImmutableMap.of(
+                "a", StarlarkInt.of(1), "b", StarlarkInt.of(2), "c", StarlarkInt.of(3)));
   }
 
   @Test
   public void testDictItemPlusEqual() throws Exception {
     ev.new Scenario()
         .setUp("def func():", "  d = {'a' : 2}", "  d['a'] += 3", "  return d", "d = func()")
-        .testLookup("d", ImmutableMap.of("a", 5));
+        .testLookup("d", ImmutableMap.of("a", StarlarkInt.of(5)));
   }
 
   @Test
   public void testDictAssignmentAsLValueSideEffects() throws Exception {
     ev.new Scenario()
         .setUp("def func(d):", "  d['b'] = 2", "d = {'a' : 1}", "func(d)")
-        .testLookup("d", Dict.of((Mutability) null, "a", 1, "b", 2));
+        .testLookup(
+            "d", Dict.of((Mutability) null, "a", StarlarkInt.of(1), "b", StarlarkInt.of(2)));
   }
 
   @Test
   public void testAssignmentToListInDictSideEffect() throws Exception {
     ev.new Scenario()
         .setUp("l = [1, 2]", "d = {0: l}", "d[0].append(3)")
-        .testLookup("l", StarlarkList.of(null, 1, 2, 3));
+        .testLookup(
+            "l", StarlarkList.of(null, StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3)));
   }
 
   @Test
   public void testUserFunctionKeywordArgs() throws Exception {
     ev.new Scenario()
         .setUp("def foo(a, b, c):", "  return a + b + c", "s = foo(1, c=2, b=3)")
-        .testLookup("s", 6);
+        .testLookup("s", StarlarkInt.of(6));
   }
 
   @Test
   public void testFunctionCallOrdering() throws Exception {
     ev.new Scenario()
         .setUp("def func(): return foo() * 2", "def foo(): return 2", "x = func()")
-        .testLookup("x", 4);
+        .testLookup("x", StarlarkInt.of(4));
   }
 
   @Test
@@ -1733,7 +1768,7 @@
             "        else:",
             "            a = i",
             "res = beforeEven([1, 3, 4, 5])")
-        .testLookup("res", 3);
+        .testLookup("res", StarlarkInt.of(3));
   }
 
   @Test
@@ -1833,12 +1868,14 @@
 
   @Test
   public void testCannotCreateMixedListInStarlark() throws Exception {
-    ev.new Scenario().testExactOrder("['a', 'b', 1, 2]", "a", "b", 1, 2);
+    ev.new Scenario()
+        .testExactOrder("['a', 'b', 1, 2]", "a", "b", StarlarkInt.of(1), StarlarkInt.of(2));
   }
 
   @Test
   public void testCannotConcatListInStarlarkWithDifferentGenericTypes() throws Exception {
-    ev.new Scenario().testExactOrder("[1, 2] + ['a', 'b']", 1, 2, "a", "b");
+    ev.new Scenario()
+        .testExactOrder("[1, 2] + ['a', 'b']", StarlarkInt.of(1), StarlarkInt.of(2), "a", "b");
   }
 
   @Test
@@ -1853,13 +1890,14 @@
 
   @Test
   public void testSingletonTuple() throws Exception {
-    ev.new Scenario().testExactOrder("(1,)", 1);
+    ev.new Scenario().testExactOrder("(1,)", StarlarkInt.of(1));
   }
 
   @Test
   public void testDirFindsClassObjectFields() throws Exception {
     ev.new Scenario()
-        .update("s", new SimpleStruct(ImmutableMap.of("a", 1, "b", 2)))
+        .update(
+            "s", new SimpleStruct(ImmutableMap.of("a", StarlarkInt.of(1), "b", StarlarkInt.of(2))))
         .testExactOrder("dir(s)", "a", "b");
   }
 
@@ -1870,6 +1908,7 @@
         .testExactOrder(
             "dir(mock)",
             "function",
+            "int_conversion",
             "interrupted_struct_field",
             "is_empty",
             "nullfunc_failing",
@@ -1918,14 +1957,14 @@
 
   @Test
   public void testConditionalExpressionAtToplevel() throws Exception {
-    ev.new Scenario().setUp("x = 1 if 2 else 3").testLookup("x", 1);
+    ev.new Scenario().setUp("x = 1 if 2 else 3").testLookup("x", StarlarkInt.of(1));
   }
 
   @Test
   public void testConditionalExpressionInFunction() throws Exception {
     ev.new Scenario()
         .setUp("def foo(a, b, c): return a+b if c else a-b\n")
-        .testExpression("foo(23, 5, 0)", 18);
+        .testExpression("foo(23, 5, 0)", StarlarkInt.of(18));
   }
 
   // SimpleStructWithMethods augments SimpleStruct's fields with annotated Java methods.
@@ -2051,7 +2090,7 @@
         "  b = [a for a in range(3)]",
         "  return a",
         "x = foo()");
-    assertThat(ev.lookup("x")).isEqualTo(18);
+    assertThat(ev.lookup("x")).isEqualTo(StarlarkInt.of(18));
   }
 
   @Test
@@ -2062,7 +2101,7 @@
         "def f():",
         "  return x",
         "y = [f() for x in [2]][0]");
-    assertThat(ev.lookup("y")).isEqualTo(1);
+    assertThat(ev.lookup("y")).isEqualTo(StarlarkInt.of(1));
   }
 
   @Test
@@ -2083,4 +2122,23 @@
             () -> Starlark.addMethods(ImmutableMap.builder(), new Mock()));
     assertThat(ex).hasMessageThat().contains("method struct_field has structField=true");
   }
+
+  @Test
+  public void testIntegerReboxing() throws Exception {
+    ev.new Scenario()
+        .update("mock", new Mock())
+        .setUp("big = 111111111 * 111111111")
+        .testExpression("mock.int_conversion(1, 2, 3, 4)", "(1, 2, 3, 4)")
+        .testExpression("mock.int_conversion(1, 'b', 3, 'd')", "(1, b, 3, d)")
+        .testIfErrorContains(
+            "got 12345678987654321 for a, want value in signed 32-bit range",
+            "mock.int_conversion(big, 0, 0, 0)")
+        .testIfErrorContains(
+            "got 12345678987654321 for b, want value in signed 32-bit range",
+            "mock.int_conversion(0, big, 0, 0)")
+        .testIfErrorContains(
+            "got 12345678987654321 for c, want value in signed 32-bit range",
+            "mock.int_conversion(0, 0, big, 0)")
+        .testExpression("mock.int_conversion(0, 0, 0, big)", "(0, 0, 0, 12345678987654321)");
+  }
 }
diff --git a/src/test/java/net/starlark/java/eval/StarlarkListTest.java b/src/test/java/net/starlark/java/eval/StarlarkListTest.java
index 17b3fbc..dd75283 100644
--- a/src/test/java/net/starlark/java/eval/StarlarkListTest.java
+++ b/src/test/java/net/starlark/java/eval/StarlarkListTest.java
@@ -33,14 +33,14 @@
   @Test
   public void testIndex() throws Exception {
     ev.exec("l = [1, '2', 3]");
-    assertThat(ev.eval("l[0]")).isEqualTo(1);
+    assertThat(ev.eval("l[0]")).isEqualTo(StarlarkInt.of(1));
     assertThat(ev.eval("l[1]")).isEqualTo("2");
-    assertThat(ev.eval("l[2]")).isEqualTo(3);
+    assertThat(ev.eval("l[2]")).isEqualTo(StarlarkInt.of(3));
 
     ev.exec("t = (1, '2', 3)");
-    assertThat(ev.eval("t[0]")).isEqualTo(1);
+    assertThat(ev.eval("t[0]")).isEqualTo(StarlarkInt.of(1));
     assertThat(ev.eval("t[1]")).isEqualTo("2");
-    assertThat(ev.eval("t[2]")).isEqualTo(3);
+    assertThat(ev.eval("t[2]")).isEqualTo(StarlarkInt.of(3));
   }
 
   @Test
@@ -145,19 +145,25 @@
 
   @Test
   public void testListSize() throws Exception {
-    assertThat(ev.eval("len([42, 'hello, world', []])")).isEqualTo(3);
+    assertThat(ev.eval("len([42, 'hello, world', []])")).isEqualTo(StarlarkInt.of(3));
   }
 
   @Test
   public void testListEmpty() throws Exception {
-    assertThat(ev.eval("8 if [1, 2, 3] else 9")).isEqualTo(8);
-    assertThat(ev.eval("8 if [] else 9")).isEqualTo(9);
+    assertThat(ev.eval("8 if [1, 2, 3] else 9")).isEqualTo(StarlarkInt.of(8));
+    assertThat(ev.eval("8 if [] else 9")).isEqualTo(StarlarkInt.of(9));
   }
 
   @Test
   public void testListConcat() throws Exception {
     assertThat(ev.eval("[1, 2] + [3, 4]"))
-        .isEqualTo(StarlarkList.of(/*mutability=*/ null, 1, 2, 3, 4));
+        .isEqualTo(
+            StarlarkList.of(
+                /*mutability=*/ null,
+                StarlarkInt.of(1),
+                StarlarkInt.of(2),
+                StarlarkInt.of(3),
+                StarlarkInt.of(4)));
   }
 
   @Test
@@ -168,10 +174,10 @@
         "e1 = l[1]",
         "e2 = l[2]",
         "e3 = l[3]");
-    assertThat(ev.lookup("e0")).isEqualTo(1);
-    assertThat(ev.lookup("e1")).isEqualTo(2);
-    assertThat(ev.lookup("e2")).isEqualTo(3);
-    assertThat(ev.lookup("e3")).isEqualTo(4);
+    assertThat(ev.lookup("e0")).isEqualTo(StarlarkInt.of(1));
+    assertThat(ev.lookup("e1")).isEqualTo(StarlarkInt.of(2));
+    assertThat(ev.lookup("e2")).isEqualTo(StarlarkInt.of(3));
+    assertThat(ev.lookup("e3")).isEqualTo(StarlarkInt.of(4));
   }
 
   @Test
@@ -183,16 +189,16 @@
         "e2 = l[2]",
         "e3 = l[3]",
         "e4 = l[4]");
-    assertThat(ev.lookup("e0")).isEqualTo(1);
-    assertThat(ev.lookup("e1")).isEqualTo(2);
-    assertThat(ev.lookup("e2")).isEqualTo(3);
-    assertThat(ev.lookup("e3")).isEqualTo(4);
-    assertThat(ev.lookup("e4")).isEqualTo(5);
+    assertThat(ev.lookup("e0")).isEqualTo(StarlarkInt.of(1));
+    assertThat(ev.lookup("e1")).isEqualTo(StarlarkInt.of(2));
+    assertThat(ev.lookup("e2")).isEqualTo(StarlarkInt.of(3));
+    assertThat(ev.lookup("e3")).isEqualTo(StarlarkInt.of(4));
+    assertThat(ev.lookup("e4")).isEqualTo(StarlarkInt.of(5));
   }
 
   @Test
   public void testConcatListSize() throws Exception {
-    assertThat(ev.eval("len([1, 2] + [3, 4])")).isEqualTo(4);
+    assertThat(ev.eval("len([1, 2] + [3, 4])")).isEqualTo(StarlarkInt.of(4));
   }
 
   @Test
@@ -225,13 +231,13 @@
   @Test
   public void testConcatListNotEmpty() throws Exception {
     ev.exec("l = [1, 2] + [3, 4]", "v = 1 if l else 0");
-    assertThat(ev.lookup("v")).isEqualTo(1);
+    assertThat(ev.lookup("v")).isEqualTo(StarlarkInt.of(1));
   }
 
   @Test
   public void testConcatListEmpty() throws Exception {
     ev.exec("l = [] + []", "v = 1 if l else 0");
-    assertThat(ev.lookup("v")).isEqualTo(0);
+    assertThat(ev.lookup("v")).isEqualTo(StarlarkInt.of(0));
   }
 
   @Test
@@ -268,7 +274,9 @@
   @Test
   public void testMutatorsCheckMutability() throws Exception {
     Mutability mutability = Mutability.create("test");
-    StarlarkList<Object> list = StarlarkList.copyOf(mutability, ImmutableList.of(1, 2, 3));
+    StarlarkList<Object> list =
+        StarlarkList.copyOf(
+            mutability, ImmutableList.of(StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3)));
     mutability.freeze();
 
     // The casts force selection of the Starlark add/remove methods,
@@ -276,27 +284,37 @@
     // We could enable the List method, but then it would have to
     // report failures using unchecked exceptions.
     EvalException e =
-        assertThrows(EvalException.class, () -> list.add((Object) 4, (Location) null));
-    assertThat(e).hasMessageThat().isEqualTo("trying to mutate a frozen list value");
-    e = assertThrows(EvalException.class, () -> list.add(0, (Object) 4, (Location) null));
+        assertThrows(
+            EvalException.class, () -> list.add((Object) StarlarkInt.of(4), (Location) null));
     assertThat(e).hasMessageThat().isEqualTo("trying to mutate a frozen list value");
     e =
         assertThrows(
-            EvalException.class, () -> list.addAll(ImmutableList.of(4, 5, 6), (Location) null));
+            EvalException.class, () -> list.add(0, (Object) StarlarkInt.of(4), (Location) null));
+    assertThat(e).hasMessageThat().isEqualTo("trying to mutate a frozen list value");
+    e =
+        assertThrows(
+            EvalException.class,
+            () ->
+                list.addAll(
+                    ImmutableList.of(StarlarkInt.of(4), StarlarkInt.of(5), StarlarkInt.of(6)),
+                    (Location) null));
     assertThat(e).hasMessageThat().isEqualTo("trying to mutate a frozen list value");
     e = assertThrows(EvalException.class, () -> list.remove(0, (Location) null));
     assertThat(e).hasMessageThat().isEqualTo("trying to mutate a frozen list value");
-    e = assertThrows(EvalException.class, () -> list.set(0, 10, (Location) null));
+    e = assertThrows(EvalException.class, () -> list.set(0, StarlarkInt.of(10), (Location) null));
     assertThat(e).hasMessageThat().isEqualTo("trying to mutate a frozen list value");
   }
 
   @Test
   public void testCannotMutateAfterShallowFreeze() throws Exception {
     Mutability mutability = Mutability.createAllowingShallowFreeze("test");
-    StarlarkList<Object> list = StarlarkList.copyOf(mutability, ImmutableList.of(1, 2, 3));
+    StarlarkList<Object> list =
+        StarlarkList.copyOf(
+            mutability, ImmutableList.of(StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3)));
     list.unsafeShallowFreeze();
 
-    EvalException e = assertThrows(EvalException.class, () -> list.add((Object) 4, null));
+    EvalException e =
+        assertThrows(EvalException.class, () -> list.add((Object) StarlarkInt.of(4), null));
     assertThat(e).hasMessageThat().isEqualTo("trying to mutate a frozen list value");
   }
 
diff --git a/src/test/java/net/starlark/java/eval/StarlarkThreadDebuggingTest.java b/src/test/java/net/starlark/java/eval/StarlarkThreadDebuggingTest.java
index effffb3..473b8f5 100644
--- a/src/test/java/net/starlark/java/eval/StarlarkThreadDebuggingTest.java
+++ b/src/test/java/net/starlark/java/eval/StarlarkThreadDebuggingTest.java
@@ -213,11 +213,12 @@
 
   @Test
   public void testEvaluateVariableInScope() throws Exception {
-    Module module = Module.withPredeclared(StarlarkSemantics.DEFAULT, ImmutableMap.of("a", 1));
+    Module module =
+        Module.withPredeclared(StarlarkSemantics.DEFAULT, ImmutableMap.of("a", StarlarkInt.of(1)));
 
     StarlarkThread thread = newThread();
     Object a = Starlark.execFile(ParserInput.fromLines("a"), FileOptions.DEFAULT, module, thread);
-    assertThat(a).isEqualTo(1);
+    assertThat(a).isEqualTo(StarlarkInt.of(1));
   }
 
   @Test
@@ -247,6 +248,6 @@
         .isEqualTo(true);
     Starlark.execFile(ParserInput.fromLines("a = 1"), FileOptions.DEFAULT, module, thread);
     assertThat(Starlark.execFile(ParserInput.fromLines("a"), FileOptions.DEFAULT, module, thread))
-        .isEqualTo(1);
+        .isEqualTo(StarlarkInt.of(1));
   }
 }
diff --git a/src/test/java/net/starlark/java/eval/StarlarkThreadTest.java b/src/test/java/net/starlark/java/eval/StarlarkThreadTest.java
index 3afd37c..5bb6ebd 100644
--- a/src/test/java/net/starlark/java/eval/StarlarkThreadTest.java
+++ b/src/test/java/net/starlark/java/eval/StarlarkThreadTest.java
@@ -41,10 +41,10 @@
   @Test
   public void testDoubleUpdateSucceeds() throws Exception {
     assertThat(ev.lookup("VERSION")).isNull();
-    ev.update("VERSION", 42);
-    assertThat(ev.lookup("VERSION")).isEqualTo(42);
-    ev.update("VERSION", 43);
-    assertThat(ev.lookup("VERSION")).isEqualTo(43);
+    ev.update("VERSION", StarlarkInt.of(42));
+    assertThat(ev.lookup("VERSION")).isEqualTo(StarlarkInt.of(42));
+    ev.update("VERSION", StarlarkInt.of(43));
+    assertThat(ev.lookup("VERSION")).isEqualTo(StarlarkInt.of(43));
   }
 
   // Test assign through interpreter, ev.lookup through API:
@@ -87,7 +87,7 @@
       StarlarkThread thread = new StarlarkThread(mu, StarlarkSemantics.DEFAULT);
       Starlark.execFile(ParserInput.fromLines("True = 123"), FileOptions.DEFAULT, module, thread);
     }
-    assertThat(module.getGlobal("True")).isEqualTo(123);
+    assertThat(module.getGlobal("True")).isEqualTo(StarlarkInt.of(123));
   }
 
   @Test
diff --git a/src/test/java/net/starlark/java/eval/testdata/int.sky b/src/test/java/net/starlark/java/eval/testdata/int.sky
index 68d4877..e6b1680 100644
--- a/src/test/java/net/starlark/java/eval/testdata/int.sky
+++ b/src/test/java/net/starlark/java/eval/testdata/int.sky
@@ -7,10 +7,41 @@
 assert_eq(5 * 7, 35)
 assert_eq(5 - 7, -2)
 
+# big numbers (but no big literals yet)
+# TODO(adonovan): implement %x.
+assert_eq("%d" % (1 << 32), "4294967296") # ="0x100000000"
+assert_eq("%d" % (1 << 64), "18446744073709551616") # ="0x10000000000000000"
+assert_eq("%d" % (1 << 128), "340282366920938463463374607431768211456") # ="0x100000000000000000000000000000000"
+assert_eq("%d" % (-1 << 128), "-340282366920938463463374607431768211456") # ="-0x100000000000000000000000000000000"
+assert_eq((1 << 128) // (1 << 127), 2)
+
+# size boundaries
+maxint = (1<<31) - 1
+maxlong = (1<<63) - 1
+minint = -1 << 31
+minlong = -1 << 63
+assert_eq(str(maxint + 1), "2147483648")
+assert_eq(str(maxlong + 1), "9223372036854775808")
+assert_eq(str(minint - 1), "-2147483649")
+assert_eq(str(minlong - 1), "-9223372036854775809")
+
+# str(int)
+assert_eq(str(0), "0")
+assert_eq(str(1), "1")
+assert_eq(str(1<<24), "16777216")
+assert_eq(str(1<<48), "281474976710656")
+assert_eq(str(1<<96), "79228162514264337593543950336")
+assert_eq(str(-1<<24), "-16777216")
+assert_eq(str(-1<<48), "-281474976710656")
+assert_eq(str(-1<<96), "-79228162514264337593543950336")
+
 # truth
-assert_(123)
-assert_(-1)
 assert_(not 0)
+assert_(1)
+assert_(-1)
+assert_(1<<24) # int32
+assert_(1<<48) # int64
+assert_(1<<100) # big
 
 # comparisons
 assert_(5 > 2)
@@ -19,6 +50,31 @@
 assert_(not (2 + 1 > 3))
 assert_(2 + 2 <= 5)
 assert_(not (2 + 1 < 3))
+big = 1 << 100
+assert_(big == big)
+assert_(not (big != big))
+assert_(big != big + 1)
+assert_(not (big == big + 1))
+assert_(big - 1 < big and big < big + 1)
+assert_(-big - 1 < -big and -big < -big + 1)
+
+# multiplication
+assert_eq(1111 * 1111, 1234321)
+assert_eq(1111 * 1, 1111)
+assert_eq(1111 * -1, -1111)
+assert_eq(1111 * 0, 0)
+p1, p2 = 0x316c5239, 0x67c4a7d5 # 32-bit primes
+product = p1 * p2
+assert_eq(product, p2 * p1)
+assert_eq(product // p1, p2)
+assert_eq(product % p1, 0)
+assert_eq(maxint, 0x7fffffff)
+assert_eq(str(maxint * maxint), "4611686014132420609")
+assert_eq(str((1<<62) - (2<<31) + 1), "4611686014132420609")
+assert_eq(str(111111111 * 111111111), "12345678987654321")
+assert_eq(str(-(111111111 * 111111111)), "-12345678987654321")
+assert_eq(str((111111111 * 111111111) // 111111111), "111111111")
+assert_eq(str((111111111 * 111111111) // 111111111), "111111111")
 
 # division
 assert_eq(100 // 7, 14)
@@ -29,6 +85,12 @@
 assert_eq(98 // -7, -14)
 assert_eq(-98 // 7, -14)
 assert_eq(-98 // -7, 14)
+quot = 1169282 * 1000000 + 890553 # simplify when we have big literals
+assert_eq(product // 1234567, quot)
+assert_eq(product // -1234567, -quot-1)
+assert_eq(-product // 1234567, -quot-1)
+assert_eq(-product // -1234567, quot)
+assert_eq(((-1) << 31) // -1, 2147483647+1) # sole case of int // int that causes int overflow
 
 # remainder
 assert_eq(100 % 7, 2)
@@ -39,10 +101,17 @@
 assert_eq(98 % -7, 0)
 assert_eq(-98 % 7, 0)
 assert_eq(-98 % -7, 0)
+assert_eq( product %  1234567,  1013598)
+assert_eq( product % -1234567, -220969) # ditto
+assert_eq(-product % 1234567,   220969) # ditto
+assert_eq(-product % -1234567, -1013598)
 
 # precedence
 assert_eq(5 - 7 * 2 + 3, -6)
 assert_eq(4 * 5 // 2 + 5 // 2 * 4, 18)
+assert_eq(1<<8 - 1, 1 << (8-1)) # confusingly...
+assert_eq(8 | 3 ^ 4 & -2, 15)
+assert_eq(~8 >> 1 | 3 ^ 4 & -2 << 2 * 3 + 4 // -2, -5)
 
 # compound assignment
 def compound():
@@ -118,11 +187,14 @@
 assert_eq(0 >> 0, 0)
 assert_eq(1000 >> 100, 0)
 assert_eq(-10 >> 1000, -1)
+assert_eq(1 << 500 >> 499, 2)
+assert_eq(1 << 32, 0x10000 * 0x10000)
+assert_eq(1 << 64, 0x10000 * 0x10000 * 0x10000 * 0x10000)
 
-# precedence
-
-assert_eq(8 | 3 ^ 4 & -2, 15)
-assert_eq(~8 >> 1 | 3 ^ 4 & -2 << 2 * 3 + 4 // -2, -5)
+assert_eq(((0x1010 << 100) | (0x1100 << 100)) >> 100, 0x1110)
+assert_eq(((0x1010 << 100) ^ (0x1100 << 100)) >> 100, 0x0110)
+assert_eq(((0x1010 << 100) & (0x1100 << 100)) >> 100, 0x1000)
+assert_eq(~((~(0x1010 << 100)) >> 100), 0x1010)
 
 ---
 1 & False ### unsupported binary operation: int & bool
@@ -131,12 +203,8 @@
 ---
 ~False ### unsupported unary operation: ~bool
 ---
-1 << 31 ### integer overflow in left shift
----
-1 << 32 ### integer overflow in left shift
+1 << 520 ### shift count too large: 520
 ---
 1 << -4 ### negative shift count: -4
 ---
 2 >> -1 ### negative shift count: -1
----
-((-1) << 31) // -1 ### integer overflow in division
diff --git a/src/test/java/net/starlark/java/eval/testdata/int_constructor.sky b/src/test/java/net/starlark/java/eval/testdata/int_constructor.sky
index 17eb1f8..abd5861 100644
--- a/src/test/java/net/starlark/java/eval/testdata/int_constructor.sky
+++ b/src/test/java/net/starlark/java/eval/testdata/int_constructor.sky
@@ -1,9 +1,50 @@
-assert_eq(int('1'), 1)
-assert_eq(int('-1234'), -1234)
+# Tests of int(x, [base])
+
+# from number
+assert_eq(int(0), 0)
 assert_eq(int(42), 42)
 assert_eq(int(-1), -1)
+assert_eq(int(2147483647), 2147483647)
+# -2147483648 is not (yet) a valid int literal even though it's a
+# valid int value, hence the -1 expression.
+assert_eq(int(-2147483647 - 1), -2147483647 - 1)
+---
+2147483648 ### invalid base-10 integer constant: 2147483648
+---
+-2147483649 ### invalid base-10 integer constant: 2147483649
+---
+
+# from bool
 assert_eq(int(True), 1)
 assert_eq(int(False), 0)
+
+# from other
+int(None) ### parameter 'x' cannot be None
+---
+
+# from string
+int('') ### empty string
+---
+# no base
+assert_eq(int('0'), 0)
+assert_eq(int('1'), 1)
+assert_eq(int('42'), 42)
+assert_eq(int('-1'), -1)
+assert_eq(int('-1234'), -1234)
+assert_eq(int('2147483647'), 2147483647)
+assert_eq(int('-2147483648'), -2147483647 - 1)
+assert_eq(int('123456789012345678901234567891234567890'), int('123456789012345678901234567891234567891') - 1)
+assert_eq(int('-123456789012345678901234567891234567890'), int('-123456789012345678901234567891234567891') + 1)
+assert_eq(int('-0xabcdefabcdefabcdefabcdefabcdef', 0), int('-892059645479943313385225296292859375'))
+assert_eq(int('1111111111111', 2), 8191)
+assert_eq(int('1111111111111', 5), int('305175781'))
+assert_eq(int('1111111111111', 8), int('78536544841'))
+assert_eq(int('1111111111111', 10), int('1111111111111'))
+assert_eq(int('1111111111111', 16), int('300239975158033'))
+assert_eq(int('1111111111111', 36), int('4873763662273663093'))
+assert_eq(int('016'), 16) # zero ok when base != 0.
+assert_eq(int('+42'), 42) # '+' prefix ok
+# with base, no prefix
 assert_eq(int('11', 2), 3)
 assert_eq(int('11', 9), 10)
 assert_eq(int('AF', 16), 175)
@@ -11,34 +52,57 @@
 assert_eq(int('az', 36), 395)
 assert_eq(int('11', 10), 11)
 assert_eq(int('11', 0), 11)
+# base and prefix
 assert_eq(int('0b11', 0), 3)
 assert_eq(int('0B11', 2), 3)
 assert_eq(int('0o11', 0), 9)
 assert_eq(int('0O11', 8), 9)
 assert_eq(int('0XFF', 0), 255)
 assert_eq(int('0xFF', 16), 255)
-
+assert_eq(int('0b11', 0), 3)
+assert_eq(int('-0b11', 0), -3)
+assert_eq(int('+0b11', 0), 3)
+assert_eq(int('0B11', 2), 3)
+assert_eq(int('0o11', 0), 9)
+assert_eq(int('0O11', 8), 9)
+assert_eq(int('-11', 2), -3)
+assert_eq(int('016', 8), 14)
+assert_eq(int('016', 16), 22)
+assert_eq(int('0', 0), 0)
+int('0xFF', 8) ### invalid base-8 literal: "0xFF"
 ---
-int('1.5') ### invalid literal for int\(\) with base 10
+int('016', 0) ### cannot infer base when string begins with a 0: "016"
 ---
-int('ab') ### invalid literal for int\(\) with base 10: "ab"
+int('123', 3) ### invalid base-3 literal: "123"
 ---
-int(None) ### parameter 'x' cannot be None
+int('FF', 15) ### invalid base-15 literal: "FF"
 ---
-int('123', 3) ### invalid literal for int\(\) with base 3: "123"
+int('123', -1) ### invalid base -1 (want 2 <= base <= 36)
 ---
-int('FF', 15) ### invalid literal for int\(\) with base 15: "FF"
+int('123', 1) ### invalid base 1 \(want 2 <= base <= 36\)
 ---
-int('123', -1) ### int\(\) base must be >= 2 and <= 36
+int('123', 37) ### invalid base 37 \(want 2 <= base <= 36\)
 ---
-int('123', 1) ### int\(\) base must be >= 2 and <= 36
+int('123', 'x') ### parameter 'base' got value of type 'string', want 'int'
 ---
-int('123', 37) ### int\(\) base must be >= 2 and <= 36
+int(True, 2) ### can't convert non-string with explicit base
 ---
-int('0xFF', 8) ### invalid literal for int\(\) with base 8: "0xFF"
+int(True, 10) ### can't convert non-string with explicit base
 ---
-int(True, 2) ### int\(\) can't convert non-string with explicit base
+int(1, 2) ### can't convert non-string with explicit base
 ---
-int(1, 2) ### int\(\) can't convert non-string with explicit base
+# This case is allowed in Python but not Skylark
+int() ### missing 1 required positional argument: x
 ---
-int(True, 10) ### int\(\) can't convert non-string with explicit base
+# Surrounding whitespace is not allowed
+int('  42  ') ### invalid base-10 literal: "  42  "
+---
+int('-') ### invalid base-10 literal: "-"
+---
+int('+') ### invalid base-10 literal: "+"
+---
+int('0x') ### invalid base-10 literal: "0x"
+---
+int('1.5') ### invalid base-10 literal: "1.5"
+---
+int('ab') ### invalid base-10 literal: "ab"
diff --git a/src/test/java/net/starlark/java/eval/testdata/int_function.sky b/src/test/java/net/starlark/java/eval/testdata/int_function.sky
deleted file mode 100644
index ff72397..0000000
--- a/src/test/java/net/starlark/java/eval/testdata/int_function.sky
+++ /dev/null
@@ -1,95 +0,0 @@
-# int
-assert_eq(int(0), 0)
-assert_eq(int(42), 42)
-assert_eq(int(-1), -1)
-assert_eq(int(2147483647), 2147483647)
-# -2147483648 is not actually a valid int literal even though it's a
-# valid int value, hence the -1 expression.
-assert_eq(int(-2147483647 - 1), -2147483647 - 1)
-assert_eq(int(True), 1)
-assert_eq(int(False), 0)
-
----
-int(None) ### parameter 'x' cannot be None
----
-# This case is allowed in Python but not Skylark
-int() ### missing 1 required positional argument: x
----
-
-# string, no base
-# Includes same numbers as integer test cases above.
-assert_eq(int('0'), 0)
-assert_eq(int('42'), 42)
-assert_eq(int('-1'), -1)
-assert_eq(int('2147483647'), 2147483647)
-assert_eq(int('-2147483648'), -2147483647 - 1)
-# Leading zero allowed when not using base = 0.
-assert_eq(int('016'), 16)
-# Leading plus sign allowed for strings.
-assert_eq(int('+42'), 42)
-
----
-int(2147483648) ### invalid base-10 integer constant: 2147483648
----
-int(-2147483649) ### invalid base-10 integer constant: 2147483649
----
-int('') ### cannot be empty
----
-# Surrounding whitespace is not allowed
-int('  42  ') ### invalid literal for int() with base 10: "  42  "
----
-int('-') ### invalid literal for int() with base 10: "-"
----
-int('0x') ### invalid literal for int() with base 10: "0x"
----
-int('1.5') ### invalid literal for int() with base 10: "1.5"
----
-int('ab') ### invalid literal for int() with base 10: "ab"
----
-
-assert_eq(int('11', 2), 3)
-assert_eq(int('-11', 2), -3)
-assert_eq(int('11', 9), 10)
-assert_eq(int('AF', 16), 175)
-assert_eq(int('11', 36), 37)
-assert_eq(int('az', 36), 395)
-assert_eq(int('11', 10), 11)
-assert_eq(int('11', 0), 11)
-assert_eq(int('016', 8), 14)
-assert_eq(int('016', 16), 22)
-
----
-# invalid base
-int('016', 0) ### cannot infer base for int() when value begins with a 0: "016"
----
-int('123', 3) ### invalid literal for int() with base 3: "123"
----
-int('FF', 15) ### invalid literal for int() with base 15: "FF"
----
-int('123', -1) ### int() base must be >= 2 and <= 36
----
-int('123', 1) ### int() base must be >= 2 and <= 36
----
-int('123', 37) ### int() base must be >= 2 and <= 36
----
-int('123', 'x') ### base must be an integer (got 'string')
----
-
-# base with prefix
-assert_eq(int('0b11', 0), 3)
-assert_eq(int('-0b11', 0), -3)
-assert_eq(int('+0b11', 0), 3)
-assert_eq(int('0B11', 2), 3)
-assert_eq(int('0o11', 0), 9)
-assert_eq(int('0O11', 8), 9)
-assert_eq(int('0XFF', 0), 255)
-assert_eq(int('0xFF', 16), 255)
-
----
-int('0xFF', 8) ### invalid literal for int() with base 8: "0xFF"
----
-int(True, 2) ### int() can't convert non-string with explicit base
----
-int(1, 2) ### int() can't convert non-string with explicit base
----
-int(True, 10) ### int() can't convert non-string with explicit base