| // Copyright 2015 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.syntax; |
| |
| import static com.google.common.truth.Truth.assertThat; |
| import static net.starlark.java.syntax.LexerTest.assertContainsError; |
| |
| import com.google.common.base.Joiner; |
| import java.util.List; |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| import org.junit.runners.JUnit4; |
| |
| /** Tests of the Starlark resolver. */ |
| @RunWith(JUnit4.class) |
| public class ResolverTest { |
| |
| private final FileOptions.Builder options = FileOptions.builder(); |
| |
| // Resolves a file using the current options, |
| // in an environment with a single predeclared name, pre. |
| // Errors are recorded in file.errors(). |
| private StarlarkFile resolveFile(String... lines) throws SyntaxError.Exception { |
| ParserInput input = ParserInput.fromLines(lines); |
| StarlarkFile file = StarlarkFile.parse(input, options.build()); |
| Resolver.resolveFile(file, Resolver.moduleWithPredeclared("pre")); |
| return file; |
| } |
| |
| // Assertions that parsing and resolution succeeds. |
| private void assertValid(String... lines) throws SyntaxError.Exception { |
| StarlarkFile file = resolveFile(lines); |
| if (!file.ok()) { |
| throw new SyntaxError.Exception(file.errors()); |
| } |
| } |
| |
| // Asserts that parsing of the program succeeds but resolution fails |
| // with at least the specified error. |
| private void assertInvalid(String expectedError, String... lines) throws SyntaxError.Exception { |
| List<SyntaxError> errors = getResolutionErrors(lines); |
| assertContainsError(errors, expectedError); |
| } |
| |
| // Returns the non-empty list of resolution errors of the program. |
| private List<SyntaxError> getResolutionErrors(String... lines) throws SyntaxError.Exception { |
| StarlarkFile file = resolveFile(lines); |
| if (file.ok()) { |
| throw new AssertionError("resolution succeeded unexpectedly"); |
| } |
| return file.errors(); |
| } |
| |
| @Test |
| public void testAssignmentNotValidLValue() throws Exception { |
| assertInvalid("cannot assign to '\"a\"'", "'a' = 1"); |
| } |
| |
| @Test |
| public void testAugmentedAssignmentWithMultipleLValues() throws Exception { |
| assertInvalid( |
| "cannot perform augmented assignment on a list or tuple expression", // |
| "a, b += 2, 3"); |
| } |
| |
| @Test |
| public void testReturnOutsideFunction() throws Exception { |
| assertInvalid( |
| "return statements must be inside a function", // |
| "return 2\n"); |
| } |
| |
| @Test |
| public void testLoadAfterStatement() throws Exception { |
| options.requireLoadStatementsFirst(true); |
| List<SyntaxError> errors = getResolutionErrors("a = 5", "load(':b.bzl', 'c')"); |
| assertContainsError(errors, ":2:1: load statements must appear before any other statement"); |
| assertContainsError(errors, ":1:1: \tfirst non-load statement appears here"); |
| } |
| |
| @Test |
| public void testAllowLoadAfterStatement() throws Exception { |
| options.requireLoadStatementsFirst(false); |
| assertValid( |
| "a = 5", // |
| "load(':b.bzl', 'c')"); |
| } |
| |
| @Test |
| public void testDuplicateBindingWithinALoadStatement() throws Exception { |
| assertInvalid( |
| "load statement defines 'x' more than once", // |
| "load('module', 'x', 'x')"); |
| assertInvalid( |
| "load statement defines 'x' more than once", // |
| "load('module', 'x', x='y')"); |
| } |
| |
| @Test |
| public void testConflictsAtToplevel_default() throws Exception { |
| List<SyntaxError> errors = getResolutionErrors("x=1; x=2"); |
| assertContainsError(errors, ":1:6: 'x' redeclared at top level"); |
| assertContainsError(errors, ":1:1: 'x' previously declared here"); |
| |
| errors = getResolutionErrors("x=1; load('module', 'x')"); |
| assertContainsError(errors, ":1:22: conflicting file-local declaration of 'x'"); |
| assertContainsError(errors, ":1:1: 'x' previously declared as global here"); |
| // Also: "loads must appear first" |
| |
| errors = getResolutionErrors("load('module', 'x'); x=1"); |
| assertContainsError(errors, ":1:22: conflicting global declaration of 'x'"); |
| assertContainsError(errors, ":1:17: 'x' previously declared as file-local here"); |
| |
| errors = getResolutionErrors("load('module', 'x'); load('module', 'x')"); |
| assertContainsError(errors, ":1:38: 'x' redeclared at top level"); |
| assertContainsError(errors, ":1:17: 'x' previously declared here"); |
| } |
| |
| @Test |
| public void testConflictsAtToplevel_loadBindsGlobally() throws Exception { |
| options.loadBindsGlobally(true); |
| |
| List<SyntaxError> errors = getResolutionErrors("x=1; x=2"); |
| assertContainsError(errors, ":1:6: 'x' redeclared at top level"); |
| assertContainsError(errors, ":1:1: 'x' previously declared here"); |
| |
| errors = getResolutionErrors("x=1; load('module', 'x')"); |
| assertContainsError(errors, ":1:22: 'x' redeclared at top level"); |
| assertContainsError(errors, ":1:1: 'x' previously declared here"); |
| // Also: "loads must appear first" |
| |
| errors = getResolutionErrors("load('module', 'x'); x=1"); |
| assertContainsError(errors, ":1:22: 'x' redeclared at top level"); |
| assertContainsError(errors, ":1:17: 'x' previously declared here"); |
| |
| errors = getResolutionErrors("load('module', 'x'); load('module', 'x')"); |
| assertContainsError(errors, ":1:38: 'x' redeclared at top level"); |
| assertContainsError(errors, ":1:17: 'x' previously declared here"); |
| } |
| |
| @Test |
| public void testConflictsAtToplevel_allowToplevelRebinding() throws Exception { |
| // This flag allows rebinding of globals, or of file-locals, |
| // but a given name cannot be both globally and file-locally bound. |
| options.allowToplevelRebinding(true); |
| |
| assertValid("x=1; x=2"); |
| |
| List<SyntaxError> errors = getResolutionErrors("x=1; load('module', 'x')"); |
| assertContainsError(errors, ":1:22: conflicting file-local declaration of 'x'"); |
| assertContainsError(errors, ":1:1: 'x' previously declared as global here"); |
| // Also: "loads must appear first" |
| |
| errors = getResolutionErrors("load('module', 'x'); x=1"); |
| assertContainsError(errors, ":1:22: conflicting global declaration of 'x'"); |
| assertContainsError(errors, ":1:17: 'x' previously declared as file-local here"); |
| |
| assertValid("load('module', 'x'); load('module', 'x')"); |
| } |
| |
| @Test |
| public void testConflictsAtToplevel_loadBindsGlobally_allowToplevelRebinding() throws Exception { |
| options.loadBindsGlobally(true); |
| options.allowToplevelRebinding(true); |
| options.requireLoadStatementsFirst(false); |
| |
| assertValid("x=1; x=2"); |
| assertValid("x=1; load('module', 'x')"); |
| assertValid("load('module', 'x'); x=1"); |
| assertValid("load('module', 'x'); load('module', 'x')"); |
| } |
| |
| @Test |
| public void testForbiddenToplevelIfStatement() throws Exception { |
| assertInvalid( |
| "if statements are not allowed at the top level", // |
| "if pre: a = 2"); |
| } |
| |
| @Test |
| public void testUndefinedName() throws Exception { |
| assertInvalid("name 'foo' is not defined", "[foo for x in []]"); |
| } |
| |
| @Test |
| public void testFunctionLocalVariable() throws Exception { |
| assertInvalid( |
| "name 'a' is not defined", // |
| "def func2(b):", |
| " c = b", |
| " c = a", |
| "def func1():", |
| " a = 1", |
| " func2(2)"); |
| } |
| |
| @Test |
| public void testFunctionLocalVariableDoesNotEffectGlobalEnv() throws Exception { |
| assertInvalid( |
| "name 'a' is not defined", // |
| "def func1():", |
| " a = 1", |
| "def func2(b):", |
| " b = a"); |
| } |
| |
| @Test |
| public void testFunctionParameterDoesNotEffectGlobalEnv() throws Exception { |
| assertInvalid( |
| "name 'a' is not defined", // |
| "def func1(a):", |
| " return a", |
| "def func2():", |
| " b = a"); |
| } |
| |
| @Test |
| public void testDefinitionByItself() throws Exception { |
| // Variables are assumed to be statically visible in the block (even if they might not be |
| // initialized). |
| assertValid("a = a"); |
| assertValid("a += a"); |
| assertValid("[[] for _ in [] for a in a]"); |
| assertValid("def f():", " for a in a: pass"); |
| } |
| |
| @Test |
| public void testLocalEnvironmentsAreSeparate() throws Exception { |
| assertValid( |
| "def func1():", // |
| " a = 1", |
| "def func2():", |
| " a = 'abc'"); |
| } |
| |
| @Test |
| public void testBuiltinsCanBeShadowed() throws Exception { |
| assertValid("pre = 1"); |
| } |
| |
| @Test |
| public void testGlobalShadowsPredeclaredForEntireFile() throws Exception { |
| // global 'pre' shadows predeclared of same name. |
| List<SyntaxError> errors = getResolutionErrors("pre; pre = 1; pre = 2"); |
| assertContainsError(errors, ":1:15: 'pre' redeclared at top level"); |
| assertContainsError(errors, ":1:6: 'pre' previously declared here"); |
| } |
| |
| @Test |
| public void testTwoFunctionsWithTheSameName() throws Exception { |
| // Def statements act just like an assignment statement. |
| List<SyntaxError> errors = getResolutionErrors("def foo(): pass", "def foo(): pass"); |
| assertContainsError(errors, ":2:5: 'foo' redeclared at top level"); |
| assertContainsError(errors, ":1:5: 'foo' previously declared here"); |
| } |
| |
| @Test |
| public void testFunctionDefRecursion() throws Exception { |
| assertValid("def func():", " func()\n"); |
| } |
| |
| @Test |
| public void testMutualRecursion() throws Exception { |
| assertValid("def foo(i):", " bar(i)", "def bar(i):", " foo(i)", "foo(4)"); |
| } |
| |
| @Test |
| public void testFunctionDefinedBelow() throws Exception { |
| assertValid("def bar(): a = foo() + 'a'", "def foo(): return 1\n"); |
| } |
| |
| @Test |
| public void testGlobalDefinedBelow() throws Exception { |
| assertValid("def bar(): return x", "x = 5\n"); |
| } |
| |
| @Test |
| public void testLocalVariableDefinedBelow() throws Exception { |
| assertValid( |
| "def bar():", |
| " for i in pre(5):", |
| " if i > 2: return x", |
| " x = i" // x is visible in the entire function block |
| ); |
| } |
| |
| @Test |
| public void testFunctionDoesNotExist() throws Exception { |
| assertInvalid( |
| "name 'foo' is not defined", // |
| "def bar(): a = foo() + 'a'"); |
| } |
| |
| @Test |
| public void testTupleLiteralWorksForDifferentTypes() throws Exception { |
| assertValid("('a', 1)"); |
| } |
| |
| @Test |
| public void testDictExpressionDifferentValueTypeWorks() throws Exception { |
| assertValid("{'a': 1, 'b': 'c'}"); |
| } |
| |
| // Starlark built-in functions specific tests |
| |
| @Test |
| public void testFuncReturningDictAssignmentAsLValue() throws Exception { |
| assertValid( |
| "def my_dict():", // |
| " return {'a': 1}", |
| "def func():", |
| " my_dict()['b'] = 2"); |
| } |
| |
| @Test |
| public void testEmptyLiteralGenericIsSetInLaterConcatWorks() throws Exception { |
| assertValid( |
| "def func():", // |
| " s = {}", |
| " s['a'] = 'b'"); |
| } |
| |
| @Test |
| public void testBuiltinGlobalFunctionsReadOnlyInFuncDefBody() throws Exception { |
| assertValid("def func():", " rule = 'abc'"); |
| } |
| |
| @Test |
| public void testBuiltinGlobalFunctionsReadOnlyAsFuncDefArg() throws Exception { |
| assertValid("def func(rule):", " return rule"); |
| } |
| |
| @Test |
| public void testTopLevelForFails() throws Exception { |
| assertInvalid( |
| "for loops are not allowed at the top level", // |
| "for i in []: 0\n"); |
| } |
| |
| @Test |
| public void testComprehension() throws Exception { |
| // The operand of the first for clause is resolved outside the comprehension block. |
| assertInvalid("name 'x' is not defined", "[() for x in x]"); |
| assertValid("[() for x in () for x in x]"); // forward ref |
| } |
| |
| @Test |
| public void testDuplicateParameter() throws Exception { |
| assertInvalid( |
| "duplicate parameter: a", |
| "def func(a, b, a):", // |
| " a = 1"); |
| } |
| |
| @Test |
| public void testParameterOrdering() throws Exception { |
| // ordering |
| assertInvalid( |
| "required parameter a may not follow **kwargs", // |
| "def func(**kwargs, a): pass"); |
| assertInvalid( |
| "required positional parameter b may not follow an optional parameter", // |
| "def func(a=1, b): pass"); |
| assertInvalid( |
| "optional parameter may not follow **kwargs", // |
| "def func(**kwargs, a=1): pass"); |
| assertInvalid( |
| "* parameter may not follow **kwargs", // |
| "def func(**kwargs, *args): pass"); |
| assertInvalid( |
| "* parameter may not follow **kwargs", // |
| "def func(**kwargs, *): pass"); |
| assertInvalid( |
| "bare * must be followed by keyword-only parameters", // |
| "def func(*): pass"); |
| |
| // duplicate parameters |
| assertInvalid("duplicate parameter: a", "def func(a, a): pass"); |
| assertInvalid("duplicate parameter: a", "def func(a, a=1): pass"); |
| assertInvalid("duplicate parameter: a", "def func(a, *a): pass"); |
| assertInvalid("duplicate parameter: a", "def func(*a, a): pass"); |
| assertInvalid("duplicate parameter: a", "def func(*a, a=1): pass"); |
| assertInvalid("duplicate parameter: a", "def func(a, **a): pass"); |
| assertInvalid("duplicate parameter: a", "def func(*a, **a): pass"); |
| |
| // multiple * |
| assertInvalid("multiple * parameters not allowed", "def func(a, *, b, *): pass"); |
| assertInvalid("multiple * parameters not allowed", "def func(a, *args, b, *): pass"); |
| assertInvalid("multiple * parameters not allowed", "def func(a, *, b, *args): pass"); |
| assertInvalid("multiple * parameters not allowed", "def func(a, *args, b, *args): pass"); |
| |
| // multiple **kwargs |
| assertInvalid("multiple ** parameters not allowed", "def func(**kwargs, **kwargs): pass"); |
| |
| assertValid("def f(a, b, c=1, d=2, *args, e, f=3, g, **kwargs): pass"); |
| } |
| |
| @Test |
| public void testArgumentOrdering() throws Exception { |
| // positionals go before keywords |
| assertInvalid( |
| "positional argument may not follow keyword", // |
| "pre(a=1, 0)"); |
| |
| // keywords must be unique |
| assertInvalid( |
| "duplicate keyword argument: a", // |
| "pre(a=1, a=2)"); |
| |
| // no arguments after **kwargs |
| assertInvalid( |
| "positional argument may not follow **kwargs", // |
| "pre(**0, 0)"); |
| assertInvalid( |
| "keyword argument a may not follow **kwargs", // |
| "pre(**0, a=1)"); |
| assertInvalid( |
| "*args may not follow **kwargs", // |
| "pre(**0, *0)"); |
| assertInvalid( |
| "multiple **kwargs not allowed", // |
| "pre(**0, **0)"); |
| assertInvalid( |
| "*args may not follow **kwargs", // also, a parse error |
| "pre(**0, *)"); |
| |
| // bad arguments after *args |
| assertInvalid( |
| "positional argument may not follow *args", // |
| "pre(*0, 1)"); |
| assertInvalid( |
| "keyword argument a may not follow *args", // |
| "pre(*0, a=1)"); // Python (even v2) allows this |
| assertInvalid( |
| "multiple *args not allowed", // |
| "pre(*0, *0)"); |
| |
| assertValid("pre(0, a=0, *0, **0)"); |
| } |
| |
| @Test |
| public void testUndefError() throws Exception { |
| // Regression test for a poor error message. |
| List<SyntaxError> errors = getResolutionErrors("lambda: undef"); |
| assertThat(errors.get(0).message()).isEqualTo("name 'undef' is not defined"); |
| } |
| |
| @Test |
| public void testBindingScopeAndIndex() throws Exception { |
| checkBindings( |
| "xᴳ₀ = 0", // |
| "yᴳ₁ = 1", |
| "zᴳ₂ = 2", |
| "xᴳ₀(xᴳ₀, yᴳ₁, preᴾ₀)", |
| "[xᴸ₀ for xᴸ₀ in xᴳ₀ if yᴳ₁]", |
| "def fᴳ₃(xᴸ₀ = xᴳ₀):", |
| " xᴸ₀ = yᴸ₁", |
| " yᴸ₁ = zᴳ₂"); |
| |
| // Load statements create file-local bindings. |
| // Functions that reference load bindings are closures. |
| checkBindings( |
| "load('module', aᶜ₀='a', bᴸ₁='b')", // |
| "aᶜ₀, bᴸ₁", |
| "def fᴳ₀(): aᶠ₀"); |
| |
| // If a name is bound globally, all toplevel references |
| // resolve to it, even those that precede it. |
| checkBindings("preᴾ₀"); |
| checkBindings("preᴳ₀; preᴳ₀=1; preᴳ₀"); |
| |
| checkBindings( |
| "aᴳ₀, bᴳ₁ = 0, 0", // |
| "def fᴳ₂(aᴸ₀=bᴳ₁):", |
| " aᴸ₀, bᴳ₁", |
| " [(aᴸ₁, bᴳ₁) for aᴸ₁ in aᴸ₀]"); |
| |
| // Nested functions have lexical scope. |
| checkBindings( |
| "def fᴳ₀(aᴸ₀, bᶜ₁):", // b is a cell: an indirect local shared with nested functions |
| " aᴸ₀", |
| " def gᴸ₂(cᴸ₀):", |
| " bᶠ₀, cᴸ₀"); // b is a free var: a reference to a cell of an outer function |
| |
| // Multiply nested functions. |
| checkBindings( |
| "load('module', aᶜ₀='a')", |
| "bᴳ₀ = 0", |
| "def fᴳ₁(cᶜ₀):", |
| " aᶠ₀, bᴳ₀, cᶜ₀", |
| " def gᶜ₁(dᶜ₀):", |
| " aᶠ₀, bᴳ₀, cᶠ₁, dᶜ₀, fᴳ₁", |
| " def hᶜ₁(eᴸ₀):", |
| " aᶠ₀, bᴳ₀, cᶠ₁, dᶠ₂, eᴸ₀, fᴳ₁, gᶠ₃, hᶠ₄"); |
| } |
| |
| // checkBindings verifies the binding (scope and index) of each identifier. |
| // Every variable must be followed by a superscript letter (its scope) |
| // and a subscript numeral (its index). They are replaced by spaces, the |
| // file is resolved, and then the computed information is written over |
| // the spaces. The resulting string must match the input. |
| private void checkBindings(String... lines) throws Exception { |
| String src = Joiner.on("\n").join(lines); |
| StarlarkFile file = resolveFile(src.replaceAll("[₀₁₂₃₄₅₆₇₈₉ᴸᴳᶜᶠᴾᵁ]", " ")); |
| if (!file.ok()) { |
| throw new AssertionError("resolution failed: " + file.errors()); |
| } |
| String[] out = new String[] {src}; |
| new NodeVisitor() { |
| @Override |
| public void visit(Identifier id) { |
| // Replace ...x__... with ...xᴸ₀... |
| out[0] = |
| out[0].substring(0, id.getEndOffset()) |
| + "ᴸᴳᶜᶠᴾᵁ".charAt(id.getBinding().getScope().ordinal()) // follow order of enum |
| + "₀₁₂₃₄₅₆₇₈₉".charAt(id.getBinding().getIndex()) // 10 is plenty |
| + out[0].substring(id.getEndOffset() + 2); |
| } |
| }.visit(file); |
| assertThat(out[0]).isEqualTo(src); |
| } |
| } |