Add type checking of compiled expressions

This updates `Program#compileExpr` to perform type checking.

It also adds a unit test, `eval/StaticTypeCheckTest.java`, to verify static type checking behavior at the `Program` level. This differs from the existing unit test `syntax/TypeCheckerTest`, which works at the level of the type checker itself and which doesn't know the production definitions of the universal types.

Added `TypeTagger#tagExpr` to mirror `Resolver#resolveExpr`. (`TypeChecker` already has `inferTypeOf` to operate at the expression level.) Also added `TypeTagger#tagExprFunction` to set the type on the final resolved function synthesized for the expression by the resolver, since this function is not accessible from the AST.

Work toward bazelbuild#28325.

PiperOrigin-RevId: 864422737
Change-Id: I41b2599160a456bf157b554a51a36ac56b7b61e6

Author: brandjon

src/main/java/net/starlark/java/syntax/Program.java

@@ -162,8 +162,16 @@ public static Program compileFile(StarlarkFile file, Resolver.Module env)
   public static Program compileExpr(Expression expr, Resolver.Module module, FileOptions options)
       throws SyntaxError.Exception {
     Resolver.Function body = Resolver.resolveExpr(expr, module, options);
-    // TODO: #27370 - This utility method should also have some form of type checking applied to it,
-    // using whatever type definitions are available in the given module.
+
+    if (options.resolveTypeSyntax()) {
+      TypeTagger.tagExpr(expr, module);
+    }
+
+    if (options.staticTypeChecking()) {
+      StarlarkType exprType = TypeChecker.inferTypeOf(expr);
+      TypeTagger.tagExprFunction(body, exprType);
+    }
+
     return new Program(
         body,
         /* loads= */ ImmutableList.of(),

src/main/java/net/starlark/java/syntax/TypeTagger.java

@@ -373,4 +373,38 @@ public static void tagFile(StarlarkFile file, Module module) {
     TypeTagger r = new TypeTagger(file.errors, module);
     r.visit(file);
   }
+
+  /**
+   * Same as {@link #tagFile}, but for an individual expression.
+   *
+   * <p>Any errors are thrown as a {@link SyntaxError.Exception}.
+   */
+  public static void tagExpr(Expression expr, Module module) throws SyntaxError.Exception {
+    List<SyntaxError> errors = new ArrayList<>();
+    TypeTagger r = new TypeTagger(errors, module);
+
+    r.visit(expr);
+
+    if (!errors.isEmpty()) {
+      throw new SyntaxError.Exception(errors);
+    }
+  }
+
+  /**
+   * Sets the Starlark type on a {@link Resolver.Function} that the resolver generated to wrap an
+   * expression.
+   */
+  public static void tagExprFunction(Resolver.Function function, StarlarkType exprType) {
+    Types.CallableType functionType =
+        Types.callable(
+            /* parameterNames= */ ImmutableList.of(),
+            /* parameterTypes= */ ImmutableList.of(),
+            /* numPositionalOnlyParameters= */ 0,
+            /* numPositionalParameters= */ 0,
+            /* mandatoryParams= */ ImmutableSet.of(),
+            /* varargsType= */ null,
+            /* kwargsType= */ null,
+            /* returns= */ exprType);
+    setType(function, functionType);
+  }
 }

src/test/java/net/starlark/java/eval/BUILD

@@ -32,6 +32,7 @@ java_test(
         "StarlarkMutableTest.java",
         "StarlarkThreadDebuggingTest.java",
         "StarlarkThreadTest.java",
+        "StaticTypeCheckTest.java",
         "SymbolGeneratorTest.java",
     ],
     jvm_flags = [

src/test/java/net/starlark/java/eval/EvalTests.java

@@ -35,5 +35,6 @@
   StarlarkMutableTest.class,
   StarlarkThreadDebuggingTest.class,
   StarlarkThreadTest.class,
+  StaticTypeCheckTest.class,
 })
 public class EvalTests {}

src/test/java/net/starlark/java/eval/StaticTypeCheckTest.java

@@ -0,0 +1,99 @@
+// Copyright 2026 The Bazel Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package net.starlark.java.eval;
+
+import static net.starlark.java.syntax.TestUtils.assertContainsError;
+import static org.junit.Assert.assertThrows;
+
+import net.starlark.java.syntax.Expression;
+import net.starlark.java.syntax.FileOptions;
+import net.starlark.java.syntax.ParserInput;
+import net.starlark.java.syntax.Program;
+import net.starlark.java.syntax.StarlarkFile;
+import net.starlark.java.syntax.StarlarkType;
+import net.starlark.java.syntax.SyntaxError;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Integrated tests for static type checking of Starlark code.
+ *
+ * <p>For tests of the type checker logic in isolation, see syntax/TypeCheckerTest.java.
+ */
+@RunWith(JUnit4.class)
+public final class StaticTypeCheckTest {
+
+  @SuppressWarnings("FieldCanBeFinal")
+  private FileOptions.Builder options =
+      FileOptions.builder()
+          .allowTypeSyntax(true)
+          .resolveTypeSyntax(true)
+          .staticTypeChecking(true)
+          // This lets us construct simpler test cases without wrapper `def` statements.
+          .allowToplevelRebinding(true);
+
+  @SuppressWarnings("FieldCanBeFinal")
+  private Module module = Module.create();
+
+  private Program compile(String... lines) throws SyntaxError.Exception {
+    ParserInput input = ParserInput.fromLines(lines);
+    StarlarkFile file = StarlarkFile.parse(input, options.build());
+    return Program.compileFile(file, module);
+  }
+
+  private void assertValid(String... lines) {
+    try {
+      compile(lines);
+    } catch (SyntaxError.Exception ex) {
+      throw new AssertionError("Expected success, but got: " + ex.getMessage(), ex);
+    }
+  }
+
+  private void assertInvalid(String message, String... lines) {
+    SyntaxError.Exception ex = assertThrows(SyntaxError.Exception.class, () -> compile(lines));
+    assertContainsError(ex.errors(), message);
+  }
+
+  private StarlarkType inferType(String expr) throws SyntaxError.Exception {
+    ParserInput input = ParserInput.fromLines(expr);
+    Expression expression = Expression.parse(input, options.build());
+    Program program = Program.compileExpr(expression, module, options.build());
+    return program.getResolvedFunction().getFunctionType();
+  }
+
+  @Test
+  public void typecheckSuccess() {
+    assertValid("n = 123 + 123");
+  }
+
+  @Test
+  public void typecheckFailure() {
+    assertInvalid(
+        "operator '+' cannot be applied to types 'int' and 'str'",
+        """
+        n = 123 + 'abc'
+        """);
+  }
+
+  @Test
+  public void noneAsType() {
+    assertInvalid(
+        "cannot assign type 'int' to 'x' of type 'None'",
+        """
+        x : None = 123
+        """);
+  }
+}