blob: 15bbe942444026b949a12cd7d5dd7e52e8eefab7 [file] [log] [blame]
// Copyright 2014 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 com.google.devtools.build.lib.syntax;
import static com.google.common.truth.Truth.assertThat;
import static com.google.common.truth.Truth.assertWithMessage;
import static org.junit.Assert.fail;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Sets;
import com.google.devtools.build.lib.cmdline.Label;
import com.google.devtools.build.lib.events.Location;
import com.google.devtools.build.lib.events.Location.LineAndColumn;
import com.google.devtools.build.lib.syntax.DictionaryLiteral.DictionaryEntryLiteral;
import com.google.devtools.build.lib.syntax.Parser.ParsingLevel;
import com.google.devtools.build.lib.syntax.SkylarkImport.SkylarkImportSyntaxException;
import com.google.devtools.build.lib.syntax.util.EvaluationTestCase;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
/**
* Tests of parser behaviour.
*/
@RunWith(JUnit4.class)
public class ParserTest extends EvaluationTestCase {
private BuildFileAST parseFileWithComments(String... input) {
return BuildFileAST.parseString(getEventHandler(), input);
}
/** Parses build code (not Skylark) */
@Override
protected List<Statement> parseFile(String... input) {
return parseFileWithComments(input).getStatements();
}
private BuildFileAST parseFileForSkylarkAsAST(String... input) {
BuildFileAST ast = BuildFileAST.parseString(getEventHandler(), input);
return ast.validate(env, getEventHandler());
}
/** Parses Skylark code */
private List<Statement> parseFileForSkylark(String... input) {
return parseFileForSkylarkAsAST(input).getStatements();
}
private static String getText(String text, ASTNode node) {
return text.substring(node.getLocation().getStartOffset(),
node.getLocation().getEndOffset());
}
private void assertLocation(int start, int end, Location location)
throws Exception {
int actualStart = location.getStartOffset();
int actualEnd = location.getEndOffset();
if (actualStart != start || actualEnd != end) {
fail("Expected location = [" + start + ", " + end + "), found ["
+ actualStart + ", " + actualEnd + ")");
}
}
// helper func for testListLiterals:
private static int getIntElem(DictionaryEntryLiteral entry, boolean key) {
return ((IntegerLiteral) (key ? entry.getKey() : entry.getValue())).getValue();
}
// helper func for testListLiterals:
private static int getIntElem(ListLiteral list, int index) {
return ((IntegerLiteral) list.getElements().get(index)).getValue();
}
// helper func for testListLiterals:
private static DictionaryEntryLiteral getElem(DictionaryLiteral list, int index) {
return list.getEntries().get(index);
}
// helper func for testListLiterals:
private static Expression getElem(ListLiteral list, int index) {
return list.getElements().get(index);
}
// helper func for testing arguments:
private static Expression getArg(FuncallExpression f, int index) {
return f.getArguments().get(index).getValue();
}
@Test
public void testPrecedence1() throws Exception {
BinaryOperatorExpression e =
(BinaryOperatorExpression) parseExpression("'%sx' % 'foo' + 'bar'");
assertThat(e.getOperator()).isEqualTo(Operator.PLUS);
}
@Test
public void testPrecedence2() throws Exception {
BinaryOperatorExpression e =
(BinaryOperatorExpression) parseExpression("('%sx' % 'foo') + 'bar'");
assertThat(e.getOperator()).isEqualTo(Operator.PLUS);
}
@Test
public void testPrecedence3() throws Exception {
BinaryOperatorExpression e =
(BinaryOperatorExpression) parseExpression("'%sx' % ('foo' + 'bar')");
assertThat(e.getOperator()).isEqualTo(Operator.PERCENT);
}
@Test
public void testPrecedence4() throws Exception {
BinaryOperatorExpression e =
(BinaryOperatorExpression) parseExpression("1 + - (2 - 3)");
assertThat(e.getOperator()).isEqualTo(Operator.PLUS);
}
@Test
public void testPrecedence5() throws Exception {
BinaryOperatorExpression e =
(BinaryOperatorExpression) parseExpression("2 * x | y + 1");
assertThat(e.getOperator()).isEqualTo(Operator.PIPE);
}
@Test
public void testNonAssociativeOperators() throws Exception {
setFailFast(false);
parseExpression("0 < 2 < 4");
assertContainsError("Operator '<' is not associative with operator '<'");
clearEvents();
parseExpression("0 == 2 < 4");
assertContainsError("Operator '==' is not associative with operator '<'");
clearEvents();
parseExpression("1 in [1, 2] == True");
assertContainsError("Operator 'in' is not associative with operator '=='");
clearEvents();
parseExpression("1 >= 2 <= 3");
assertContainsError("Operator '>=' is not associative with operator '<='");
clearEvents();
}
@Test
public void testNonAssociativeOperatorsWithParens() throws Exception {
parseExpression("(0 < 2) < 4");
parseExpression("(0 == 2) < 4");
parseExpression("(1 in [1, 2]) == True");
parseExpression("1 >= (2 <= 3)");
}
@Test
public void testUnaryMinusExpr() throws Exception {
UnaryOperatorExpression e = (UnaryOperatorExpression) parseExpression("-5");
UnaryOperatorExpression e2 = (UnaryOperatorExpression) parseExpression("- 5");
IntegerLiteral i = (IntegerLiteral) e.getOperand();
assertThat(i.getValue()).isEqualTo(5);
IntegerLiteral i2 = (IntegerLiteral) e2.getOperand();
assertThat(i2.getValue()).isEqualTo(5);
assertLocation(0, 2, e.getLocation());
assertLocation(0, 3, e2.getLocation());
}
@Test
public void testFuncallExpr() throws Exception {
FuncallExpression e = (FuncallExpression) parseExpression("foo[0](1, 2, bar=wiz)");
IndexExpression function = (IndexExpression) e.getFunction();
Identifier functionList = (Identifier) function.getObject();
assertThat(functionList.getName()).isEqualTo("foo");
IntegerLiteral listIndex = (IntegerLiteral) function.getKey();
assertThat(listIndex.getValue()).isEqualTo(0);
assertThat(e.getArguments()).hasSize(3);
assertThat(e.getNumPositionalArguments()).isEqualTo(2);
IntegerLiteral arg0 = (IntegerLiteral) e.getArguments().get(0).getValue();
assertThat((int) arg0.getValue()).isEqualTo(1);
IntegerLiteral arg1 = (IntegerLiteral) e.getArguments().get(1).getValue();
assertThat((int) arg1.getValue()).isEqualTo(2);
Argument.Passed arg2 = e.getArguments().get(2);
assertThat(arg2.getName()).isEqualTo("bar");
Identifier arg2val = (Identifier) arg2.getValue();
assertThat(arg2val.getName()).isEqualTo("wiz");
}
@Test
public void testMethCallExpr() throws Exception {
FuncallExpression e =
(FuncallExpression) parseExpression("foo.foo(1, 2, bar=wiz)");
DotExpression dotExpression = (DotExpression) e.getFunction();
assertThat(dotExpression.getField().getName()).isEqualTo("foo");
assertThat(e.getArguments()).hasSize(3);
assertThat(e.getNumPositionalArguments()).isEqualTo(2);
IntegerLiteral arg0 = (IntegerLiteral) e.getArguments().get(0).getValue();
assertThat((int) arg0.getValue()).isEqualTo(1);
IntegerLiteral arg1 = (IntegerLiteral) e.getArguments().get(1).getValue();
assertThat((int) arg1.getValue()).isEqualTo(2);
Argument.Passed arg2 = e.getArguments().get(2);
assertThat(arg2.getName()).isEqualTo("bar");
Identifier arg2val = (Identifier) arg2.getValue();
assertThat(arg2val.getName()).isEqualTo("wiz");
}
@Test
public void testChainedMethCallExpr() throws Exception {
FuncallExpression e =
(FuncallExpression) parseExpression("foo.replace().split(1)");
DotExpression dotExpr = (DotExpression) e.getFunction();
assertThat(dotExpr.getField().getName()).isEqualTo("split");
assertThat(e.getArguments()).hasSize(1);
assertThat(e.getNumPositionalArguments()).isEqualTo(1);
IntegerLiteral arg0 = (IntegerLiteral) e.getArguments().get(0).getValue();
assertThat((int) arg0.getValue()).isEqualTo(1);
}
@Test
public void testPropRefExpr() throws Exception {
DotExpression e = (DotExpression) parseExpression("foo.foo");
Identifier ident = e.getField();
assertThat(ident.getName()).isEqualTo("foo");
}
@Test
public void testStringMethExpr() throws Exception {
FuncallExpression e = (FuncallExpression) parseExpression("'foo'.foo()");
DotExpression dotExpression = (DotExpression) e.getFunction();
assertThat(dotExpression.getField().getName()).isEqualTo("foo");
assertThat(e.getArguments()).isEmpty();
}
@Test
public void testStringLiteralOptimizationValue() throws Exception {
StringLiteral l = (StringLiteral) parseExpression("'abc' + 'def'");
assertThat(l.value).isEqualTo("abcdef");
}
@Test
public void testStringLiteralOptimizationToString() throws Exception {
StringLiteral l = (StringLiteral) parseExpression("'abc' + 'def'");
assertThat(l.toString()).isEqualTo("\"abcdef\"");
}
@Test
public void testStringLiteralOptimizationLocation() throws Exception {
StringLiteral l = (StringLiteral) parseExpression("'abc' + 'def'");
assertThat(l.getLocation().getStartOffset()).isEqualTo(0);
assertThat(l.getLocation().getEndOffset()).isEqualTo(13);
}
@Test
public void testStringLiteralOptimizationDifferentQuote() throws Exception {
StringLiteral l = (StringLiteral) parseExpression("'abc' + \"def\"");
assertThat(l.getLocation().getStartOffset()).isEqualTo(0);
assertThat(l.getLocation().getEndOffset()).isEqualTo(13);
}
@Test
public void testIndex() throws Exception {
IndexExpression e = (IndexExpression) parseExpression("a[i]");
assertThat(e.getObject().toString()).isEqualTo("a");
assertThat(e.getKey().toString()).isEqualTo("i");
assertLocation(0, 4, e.getLocation());
}
@Test
public void testSubstring() throws Exception {
SliceExpression s = (SliceExpression) parseExpression("'FOO.CC'[:].lower()[1:]");
assertThat(((IntegerLiteral) s.getStart()).getValue()).isEqualTo(1);
FuncallExpression e = (FuncallExpression) parseExpression(
"'FOO.CC'.lower()[1:].startswith('oo')");
DotExpression dotExpression = (DotExpression) e.getFunction();
assertThat(dotExpression.getField().getName()).isEqualTo("startswith");
assertThat(e.getArguments()).hasSize(1);
s = (SliceExpression) parseExpression("'FOO.CC'[1:][:2]");
assertThat(((IntegerLiteral) s.getEnd()).getValue()).isEqualTo(2);
}
@Test
public void testSlice() throws Exception {
evalSlice("'0123'[:]", "", "", "");
evalSlice("'0123'[1:]", 1, "", "");
evalSlice("'0123'[:3]", "", 3, "");
evalSlice("'0123'[::]", "", "", "");
evalSlice("'0123'[1::]", 1, "", "");
evalSlice("'0123'[:3:]", "", 3, "");
evalSlice("'0123'[::-1]", "", "", -1);
evalSlice("'0123'[1:3:]", 1, 3, "");
evalSlice("'0123'[1::-1]", 1, "", -1);
evalSlice("'0123'[:3:-1]", "", 3, -1);
evalSlice("'0123'[1:3:-1]", 1, 3, -1);
Expression slice = parseExpression("'0123'[1:3:-1]");
assertLocation(0, 14, slice.getLocation());
}
private void evalSlice(String statement, Object... expectedArgs) {
SliceExpression e = (SliceExpression) parseExpression(statement);
// There is no way to evaluate the expression here, so we rely on string comparison.
String start = e.getStart() == null ? "" : e.getStart().toString();
String end = e.getEnd() == null ? "" : e.getEnd().toString();
String step = e.getStep() == null ? "" : e.getStep().toString();
assertThat(start).isEqualTo(expectedArgs[0].toString());
assertThat(end).isEqualTo(expectedArgs[1].toString());
assertThat(step).isEqualTo(expectedArgs[2].toString());
}
@Test
public void testErrorRecovery() throws Exception {
setFailFast(false);
String expr = "f(1, [x for foo foo foo foo], 3)";
FuncallExpression e = (FuncallExpression) parseExpression(expr);
assertContainsError("syntax error at 'foo'");
// Test that the actual parameters are: (1, $error$, 3):
Identifier ident = (Identifier) e.getFunction();
assertThat(ident.getName()).isEqualTo("f");
assertThat(e.getArguments()).hasSize(3);
assertThat(e.getNumPositionalArguments()).isEqualTo(3);
IntegerLiteral arg0 = (IntegerLiteral) e.getArguments().get(0).getValue();
assertThat((int) arg0.getValue()).isEqualTo(1);
Argument.Passed arg1 = e.getArguments().get(1);
Identifier arg1val = ((Identifier) arg1.getValue());
assertThat(arg1val.getName()).isEqualTo("$error$");
assertLocation(5, 29, arg1val.getLocation());
assertThat(expr.substring(5, 28)).isEqualTo("[x for foo foo foo foo]");
assertThat(arg1val.getLocation().getEndLineAndColumn().getColumn()).isEqualTo(29);
IntegerLiteral arg2 = (IntegerLiteral) e.getArguments().get(2).getValue();
assertThat((int) arg2.getValue()).isEqualTo(3);
}
@Test
public void testDoesntGetStuck() throws Exception {
setFailFast(false);
// Make sure the parser does not get stuck when trying
// to parse an expression containing a syntax error.
// This usually results in OutOfMemoryError because the
// parser keeps filling up the error log.
// We need to make sure that we will always advance
// in the token stream.
parseExpression("f(1, ], 3)");
parseExpression("f(1, ), 3)");
parseExpression("[ ) for v in 3)");
assertContainsError(""); // "" matches any, i.e., there were some events
}
@Test
public void testSecondaryLocation() {
String expr = "f(1 % 2)";
FuncallExpression call = (FuncallExpression) parseExpression(expr);
Argument.Passed arg = call.getArguments().get(0);
assertThat(arg.getLocation().getEndOffset()).isLessThan(call.getLocation().getEndOffset());
}
@Test
public void testPrimaryLocation() {
String expr = "f(1 + 2)";
FuncallExpression call = (FuncallExpression) parseExpression(expr);
Argument.Passed arg = call.getArguments().get(0);
assertThat(arg.getLocation().getEndOffset()).isLessThan(call.getLocation().getEndOffset());
}
@Test
public void testAssignLocation() {
List<Statement> statements = parseFile("a = b;c = d\n");
Statement statement = statements.get(0);
assertThat(statement.getLocation().getEndOffset()).isEqualTo(5);
}
@Test
public void testAssignKeyword() {
setFailFast(false);
parseExpression("with = 4");
assertContainsError("keyword 'with' not supported");
assertContainsError("syntax error at 'with': expected expression");
}
@Test
public void testBreak() {
setFailFast(false);
parseExpression("break");
assertContainsError("syntax error at 'break': expected expression");
}
@Test
public void testTry() {
setFailFast(false);
parseExpression("try: 1 + 1");
assertContainsError("'try' not supported, all exceptions are fatal");
assertContainsError("syntax error at 'try': expected expression");
}
@Test
public void testDel() {
setFailFast(false);
parseExpression("del d['a']");
assertContainsError("'del' not supported, use '.pop()' to delete");
}
@Test
public void testTupleAssign() {
List<Statement> statements = parseFile("list[0] = 5; dict['key'] = value\n");
assertThat(statements).hasSize(2);
assertThat(statements.get(0)).isInstanceOf(AssignmentStatement.class);
assertThat(statements.get(1)).isInstanceOf(AssignmentStatement.class);
}
@Test
public void testAssign() {
List<Statement> statements = parseFile("a, b = 5\n");
assertThat(statements).hasSize(1);
assertThat(statements.get(0)).isInstanceOf(AssignmentStatement.class);
AssignmentStatement assign = (AssignmentStatement) statements.get(0);
assertThat(assign.getLValue().getExpression()).isInstanceOf(ListLiteral.class);
}
@Test
public void testInvalidAssign() {
setFailFast(false);
parseExpression("1 + (b = c)");
assertContainsError("syntax error");
clearEvents();
}
@Test
public void testAugmentedAssign() throws Exception {
assertThat(parseFile("x += 1").toString()).isEqualTo("[x += 1\n]");
assertThat(parseFile("x -= 1").toString()).isEqualTo("[x -= 1\n]");
assertThat(parseFile("x *= 1").toString()).isEqualTo("[x *= 1\n]");
assertThat(parseFile("x /= 1").toString()).isEqualTo("[x /= 1\n]");
assertThat(parseFile("x %= 1").toString()).isEqualTo("[x %= 1\n]");
}
@Test
public void testPrettyPrintFunctions() throws Exception {
assertThat(parseFile("x[1:3]").toString()).isEqualTo("[x[1:3]\n]");
assertThat(parseFile("x[1:3:1]").toString()).isEqualTo("[x[1:3:1]\n]");
assertThat(parseFile("x[1:3:2]").toString()).isEqualTo("[x[1:3:2]\n]");
assertThat(parseFile("x[1::2]").toString()).isEqualTo("[x[1::2]\n]");
assertThat(parseFile("x[1:]").toString()).isEqualTo("[x[1:]\n]");
assertThat(parseFile("str[42]").toString()).isEqualTo("[str[42]\n]");
assertThat(parseFile("ctx.actions.declare_file('hello')").toString())
.isEqualTo("[ctx.actions.declare_file(\"hello\")\n]");
assertThat(parseFile("new_file(\"hello\")").toString()).isEqualTo("[new_file(\"hello\")\n]");
}
@Test
public void testEndLineAndColumnIsInclusive() {
AssignmentStatement stmt =
(AssignmentStatement) parseStatement(ParsingLevel.LOCAL_LEVEL, "a = b");
assertThat(stmt.getLValue().getLocation().getEndLineAndColumn())
.isEqualTo(new LineAndColumn(1, 1));
}
@Test
public void testFuncallLocation() {
List<Statement> statements = parseFile("a(b);c = d\n");
Statement statement = statements.get(0);
assertThat(statement.getLocation().getEndOffset()).isEqualTo(4);
}
@Test
public void testListPositions() throws Exception {
String expr = "[0,f(1),2]";
assertExpressionLocationCorrect(expr);
ListLiteral list = (ListLiteral) parseExpression(expr);
assertThat(getText(expr, getElem(list, 0))).isEqualTo("0");
assertThat(getText(expr, getElem(list, 1))).isEqualTo("f(1)");
assertThat(getText(expr, getElem(list, 2))).isEqualTo("2");
}
@Test
public void testDictPositions() throws Exception {
String expr = "{1:2,2:f(1),3:4}";
assertExpressionLocationCorrect(expr);
DictionaryLiteral list = (DictionaryLiteral) parseExpression(expr);
assertThat(getText(expr, getElem(list, 0))).isEqualTo("1:2");
assertThat(getText(expr, getElem(list, 1))).isEqualTo("2:f(1)");
assertThat(getText(expr, getElem(list, 2))).isEqualTo("3:4");
}
@Test
public void testArgumentPositions() throws Exception {
String expr = "f(0,g(1,2),2)";
assertExpressionLocationCorrect(expr);
FuncallExpression f = (FuncallExpression) parseExpression(expr);
assertThat(getText(expr, getArg(f, 0))).isEqualTo("0");
assertThat(getText(expr, getArg(f, 1))).isEqualTo("g(1,2)");
assertThat(getText(expr, getArg(f, 2))).isEqualTo("2");
}
@Test
public void testSuffixPosition() throws Exception {
assertExpressionLocationCorrect("'a'.len");
assertExpressionLocationCorrect("'a'[0]");
assertExpressionLocationCorrect("'a'[0:1]");
}
@Test
public void testTuplePosition() throws Exception {
String input = "for a,b in []: pass";
ForStatement stmt = (ForStatement) parseStatement(ParsingLevel.LOCAL_LEVEL, input);
assertThat(getText(input, stmt.getVariable())).isEqualTo("a,b");
input = "for (a,b) in []: pass";
stmt = (ForStatement) parseStatement(ParsingLevel.LOCAL_LEVEL, input);
assertThat(getText(input, stmt.getVariable())).isEqualTo("(a,b)");
assertExpressionLocationCorrect("a, b");
assertExpressionLocationCorrect("(a, b)");
}
@Test
public void testComprehensionPosition() throws Exception {
assertExpressionLocationCorrect("[[] for x in []]");
assertExpressionLocationCorrect("{1: [] for x in []}");
}
@Test
public void testUnaryOperationPosition() throws Exception {
assertExpressionLocationCorrect("not True");
}
@Test
public void testLoadStatementPosition() throws Exception {
String input = "load(':foo.bzl', 'bar')";
LoadStatement stmt = (LoadStatement) parseFile(input).get(0);
assertThat(getText(input, stmt)).isEqualTo(input);
// Also try it with another token at the end (newline), which broke the location in the past.
stmt = (LoadStatement) parseFile(input + "\n").get(0);
assertThat(getText(input, stmt)).isEqualTo(input);
}
@Test
public void testIfStatementPosition() throws Exception {
assertStatementLocationCorrect(ParsingLevel.LOCAL_LEVEL, "if True:\n pass");
assertStatementLocationCorrect(
ParsingLevel.LOCAL_LEVEL, "if True:\n pass\nelif True:\n pass");
assertStatementLocationCorrect(ParsingLevel.LOCAL_LEVEL, "if True:\n pass\nelse:\n pass");
}
@Test
public void testForStatementPosition() throws Exception {
assertStatementLocationCorrect(ParsingLevel.LOCAL_LEVEL, "for x in []:\n pass");
}
@Test
public void testDefStatementPosition() throws Exception {
assertStatementLocationCorrect(ParsingLevel.TOP_LEVEL, "def foo():\n pass");
}
private void assertStatementLocationCorrect(ParsingLevel level, String stmtStr) {
Statement stmt = parseStatement(level, stmtStr);
assertThat(getText(stmtStr, stmt)).isEqualTo(stmtStr);
// Also try it with another token at the end (newline), which broke the location in the past.
stmt = parseStatement(level, stmtStr + "\n");
assertThat(getText(stmtStr, stmt)).isEqualTo(stmtStr);
}
private void assertExpressionLocationCorrect(String exprStr) {
Expression expr = parseExpression(exprStr);
assertThat(getText(exprStr, expr)).isEqualTo(exprStr);
// Also try it with another token at the end (newline), which broke the location in the past.
expr = parseExpression(exprStr + "\n");
assertThat(getText(exprStr, expr)).isEqualTo(exprStr);
}
@Test
public void testForBreakContinue() throws Exception {
List<Statement> file = parseFileForSkylark(
"def foo():",
" for i in [1, 2]:",
" break",
" continue",
" break");
assertThat(file).hasSize(1);
List<Statement> body = ((FunctionDefStatement) file.get(0)).getStatements();
assertThat(body).hasSize(1);
List<Statement> loop = ((ForStatement) body.get(0)).getBlock();
assertThat(loop).hasSize(3);
assertThat(((FlowStatement) loop.get(0)).getKind()).isEqualTo(FlowStatement.Kind.BREAK);
assertLocation(34, 39, loop.get(0).getLocation());
assertThat(((FlowStatement) loop.get(1)).getKind()).isEqualTo(FlowStatement.Kind.CONTINUE);
assertLocation(44, 52, loop.get(1).getLocation());
assertThat(((FlowStatement) loop.get(2)).getKind()).isEqualTo(FlowStatement.Kind.BREAK);
assertLocation(57, 62, loop.get(2).getLocation());
}
@Test
public void testListLiterals1() throws Exception {
ListLiteral list = (ListLiteral) parseExpression("[0,1,2]");
assertThat(list.isTuple()).isFalse();
assertThat(list.getElements()).hasSize(3);
assertThat(list.isTuple()).isFalse();
for (int i = 0; i < 3; ++i) {
assertThat(getIntElem(list, i)).isEqualTo(i);
}
}
@Test
public void testTupleLiterals2() throws Exception {
ListLiteral tuple = (ListLiteral) parseExpression("(0,1,2)");
assertThat(tuple.isTuple()).isTrue();
assertThat(tuple.getElements()).hasSize(3);
assertThat(tuple.isTuple()).isTrue();
for (int i = 0; i < 3; ++i) {
assertThat(getIntElem(tuple, i)).isEqualTo(i);
}
}
@Test
public void testTupleWithoutParens() throws Exception {
ListLiteral tuple = (ListLiteral) parseExpression("0, 1, 2");
assertThat(tuple.isTuple()).isTrue();
assertThat(tuple.getElements()).hasSize(3);
assertThat(tuple.isTuple()).isTrue();
for (int i = 0; i < 3; ++i) {
assertThat(getIntElem(tuple, i)).isEqualTo(i);
}
}
@Test
public void testTupleWithTrailingComma() throws Exception {
setFailFast(false);
// Unlike Python, we require parens here.
parseExpression("0, 1, 2, 3,");
assertContainsError("Trailing comma");
clearEvents();
parseExpression("1 + 2,");
assertContainsError("Trailing comma");
clearEvents();
ListLiteral tuple = (ListLiteral) parseExpression("(0, 1, 2, 3,)");
assertThat(tuple.isTuple()).isTrue();
assertThat(tuple.getElements()).hasSize(4);
assertThat(tuple.isTuple()).isTrue();
for (int i = 0; i < 4; ++i) {
assertThat(getIntElem(tuple, i)).isEqualTo(i);
}
}
@Test
public void testTupleLiterals3() throws Exception {
ListLiteral emptyTuple = (ListLiteral) parseExpression("()");
assertThat(emptyTuple.isTuple()).isTrue();
assertThat(emptyTuple.getElements()).isEmpty();
}
@Test
public void testTupleLiterals4() throws Exception {
ListLiteral singletonTuple = (ListLiteral) parseExpression("(42,)");
assertThat(singletonTuple.isTuple()).isTrue();
assertThat(singletonTuple.getElements()).hasSize(1);
assertThat(getIntElem(singletonTuple, 0)).isEqualTo(42);
}
@Test
public void testTupleLiterals5() throws Exception {
IntegerLiteral intLit = (IntegerLiteral) parseExpression("(42)"); // not a tuple!
assertThat((int) intLit.getValue()).isEqualTo(42);
}
@Test
public void testListLiterals6() throws Exception {
ListLiteral emptyList = (ListLiteral) parseExpression("[]");
assertThat(emptyList.isTuple()).isFalse();
assertThat(emptyList.getElements()).isEmpty();
}
@Test
public void testListLiterals7() throws Exception {
ListLiteral singletonList = (ListLiteral) parseExpression("[42,]");
assertThat(singletonList.isTuple()).isFalse();
assertThat(singletonList.getElements()).hasSize(1);
assertThat(getIntElem(singletonList, 0)).isEqualTo(42);
}
@Test
public void testListLiterals8() throws Exception {
ListLiteral singletonList = (ListLiteral) parseExpression("[42]"); // a singleton
assertThat(singletonList.isTuple()).isFalse();
assertThat(singletonList.getElements()).hasSize(1);
assertThat(getIntElem(singletonList, 0)).isEqualTo(42);
}
@Test
public void testDictionaryLiterals() throws Exception {
DictionaryLiteral dictionaryList =
(DictionaryLiteral) parseExpression("{1:42}"); // a singleton dictionary
assertThat(dictionaryList.getEntries()).hasSize(1);
DictionaryEntryLiteral tuple = getElem(dictionaryList, 0);
assertThat(getIntElem(tuple, true)).isEqualTo(1);
assertThat(getIntElem(tuple, false)).isEqualTo(42);
}
@Test
public void testDictionaryLiterals1() throws Exception {
DictionaryLiteral dictionaryList =
(DictionaryLiteral) parseExpression("{}"); // an empty dictionary
assertThat(dictionaryList.getEntries()).isEmpty();
}
@Test
public void testDictionaryLiterals2() throws Exception {
DictionaryLiteral dictionaryList =
(DictionaryLiteral) parseExpression("{1:42,}"); // a singleton dictionary
assertThat(dictionaryList.getEntries()).hasSize(1);
DictionaryEntryLiteral tuple = getElem(dictionaryList, 0);
assertThat(getIntElem(tuple, true)).isEqualTo(1);
assertThat(getIntElem(tuple, false)).isEqualTo(42);
}
@Test
public void testDictionaryLiterals3() throws Exception {
DictionaryLiteral dictionaryList = (DictionaryLiteral) parseExpression("{1:42,2:43,3:44}");
assertThat(dictionaryList.getEntries()).hasSize(3);
for (int i = 0; i < 3; i++) {
DictionaryEntryLiteral tuple = getElem(dictionaryList, i);
assertThat(getIntElem(tuple, true)).isEqualTo(i + 1);
assertThat(getIntElem(tuple, false)).isEqualTo(i + 42);
}
}
@Test
public void testListLiterals9() throws Exception {
ListLiteral singletonList =
(ListLiteral) parseExpression("[ abi + opt_level + \'/include\' ]");
assertThat(singletonList.isTuple()).isFalse();
assertThat(singletonList.getElements()).hasSize(1);
}
@Test
public void testListComprehensionSyntax() throws Exception {
setFailFast(false);
parseExpression("[x for");
assertContainsError("syntax error at 'newline'");
clearEvents();
parseExpression("[x for x");
assertContainsError("syntax error at 'newline'");
clearEvents();
parseExpression("[x for x in");
assertContainsError("syntax error at 'newline'");
clearEvents();
parseExpression("[x for x in []");
assertContainsError("syntax error at 'newline'");
clearEvents();
parseExpression("[x for x for y in ['a']]");
assertContainsError("syntax error at 'for'");
clearEvents();
parseExpression("[x for x for y in 1, 2]");
assertContainsError("syntax error at 'for'");
clearEvents();
}
@Test
public void testListComprehensionEmptyList() throws Exception {
List<ListComprehension.Clause> clauses = ((ListComprehension) parseExpression(
"['foo/%s.java' % x for x in []]")).getClauses();
assertThat(clauses).hasSize(1);
assertThat(clauses.get(0).getExpression().toString()).isEqualTo("[]");
assertThat(clauses.get(0).getLValue().getExpression().toString()).isEqualTo("x");
}
@Test
public void testListComprehension() throws Exception {
List<ListComprehension.Clause> clauses = ((ListComprehension) parseExpression(
"['foo/%s.java' % x for x in ['bar', 'wiz', 'quux']]")).getClauses();
assertThat(clauses).hasSize(1);
assertThat(clauses.get(0).getLValue().getExpression().toString()).isEqualTo("x");
assertThat(clauses.get(0).getExpression()).isInstanceOf(ListLiteral.class);
}
@Test
public void testForForListComprehension() throws Exception {
List<ListComprehension.Clause> clauses = ((ListComprehension) parseExpression(
"['%s/%s.java' % (x, y) for x in ['foo', 'bar'] for y in list]")).getClauses();
assertThat(clauses).hasSize(2);
assertThat(clauses.get(0).getLValue().getExpression().toString()).isEqualTo("x");
assertThat(clauses.get(0).getExpression()).isInstanceOf(ListLiteral.class);
assertThat(clauses.get(1).getLValue().getExpression().toString()).isEqualTo("y");
assertThat(clauses.get(1).getExpression()).isInstanceOf(Identifier.class);
}
@Test
public void testParserRecovery() throws Exception {
setFailFast(false);
List<Statement> statements = parseFileForSkylark(
"def foo():",
" a = 2 for 4", // parse error
" b = [3, 4]",
"",
"d = 4 ada", // parse error
"",
"def bar():",
" a = [3, 4]",
" b = 2 + + 5", // parse error
"");
assertThat(getEventCollector()).hasSize(3);
assertContainsError("syntax error at 'for': expected newline");
assertContainsError("syntax error at 'ada': expected newline");
assertContainsError("syntax error at '+': expected expression");
assertThat(statements).hasSize(3);
}
@Test
public void testParserContainsErrorsIfSyntaxException() throws Exception {
setFailFast(false);
parseExpression("'foo' %%");
assertContainsError("syntax error at '%'");
}
@Test
public void testParserDoesNotContainErrorsIfSuccess() throws Exception {
parseExpression("'foo'");
}
@Test
public void testParserContainsErrors() throws Exception {
setFailFast(false);
parseFile("+");
assertContainsError("syntax error at '+'");
}
@Test
public void testSemicolonAndNewline() throws Exception {
List<Statement> stmts = parseFile(
"foo='bar'; foo(bar)",
"",
"foo='bar'; foo(bar)");
assertThat(stmts).hasSize(4);
}
@Test
public void testSemicolonAndNewline2() throws Exception {
setFailFast(false);
List<Statement> stmts = parseFile(
"foo='foo' error(bar)",
"",
"");
assertContainsError("syntax error at 'error'");
assertThat(stmts).hasSize(1);
}
@Test
public void testExprAsStatement() throws Exception {
List<Statement> stmts = parseFile(
"li = []",
"li.append('a.c')",
"\"\"\" string comment \"\"\"",
"foo(bar)");
assertThat(stmts).hasSize(4);
}
@Test
public void testParseBuildFileWithSingeRule() throws Exception {
List<Statement> stmts = parseFile(
"genrule(name = 'foo',",
" srcs = ['input.csv'],",
" outs = [ 'result.txt',",
" 'result.log'],",
" cmd = 'touch result.txt result.log')",
"");
assertThat(stmts).hasSize(1);
}
@Test
public void testParseBuildFileWithMultipleRules() throws Exception {
List<Statement> stmts = parseFile(
"genrule(name = 'foo',",
" srcs = ['input.csv'],",
" outs = [ 'result.txt',",
" 'result.log'],",
" cmd = 'touch result.txt result.log')",
"",
"genrule(name = 'bar',",
" srcs = ['input.csv'],",
" outs = [ 'graph.svg'],",
" cmd = 'touch graph.svg')");
assertThat(stmts).hasSize(2);
}
@Test
public void testParseBuildFileWithComments() throws Exception {
BuildFileAST result = parseFileWithComments(
"# Test BUILD file",
"# with multi-line comment",
"",
"genrule(name = 'foo',",
" srcs = ['input.csv'],",
" outs = [ 'result.txt',",
" 'result.log'],",
" cmd = 'touch result.txt result.log')");
assertThat(result.getStatements()).hasSize(1);
assertThat(result.getComments()).hasSize(2);
}
@Test
public void testParseBuildFileWithManyComments() throws Exception {
BuildFileAST result = parseFileWithComments(
"# 1",
"# 2",
"",
"# 4 ",
"# 5",
"#", // 6 - find empty comment for syntax highlighting
"# 7 ",
"# 8",
"genrule(name = 'foo',",
" srcs = ['input.csv'],",
" # 11",
" outs = [ 'result.txt',",
" 'result.log'], # 13",
" cmd = 'touch result.txt result.log')",
"# 15");
assertThat(result.getStatements()).hasSize(1); // Single genrule
StringBuilder commentLines = new StringBuilder();
for (Comment comment : result.getComments()) {
// Comments start and end on the same line
assertWithMessage(
comment.getLocation().getStartLineAndColumn().getLine()
+ " ends on "
+ comment.getLocation().getEndLineAndColumn().getLine())
.that(comment.getLocation().getEndLineAndColumn().getLine())
.isEqualTo(comment.getLocation().getStartLineAndColumn().getLine());
commentLines.append('(');
commentLines.append(comment.getLocation().getStartLineAndColumn().getLine());
commentLines.append(',');
commentLines.append(comment.getLocation().getStartLineAndColumn().getColumn());
commentLines.append(") ");
}
assertWithMessage("Found: " + commentLines)
.that(result.getComments().size()).isEqualTo(10); // One per '#'
}
@Test
public void testMissingComma() throws Exception {
setFailFast(false);
// Regression test.
// Note: missing comma after name='foo'
parseFile("genrule(name = 'foo'\n"
+ " srcs = ['in'])");
assertContainsError("syntax error at 'srcs'");
}
@Test
public void testDoubleSemicolon() throws Exception {
setFailFast(false);
// Regression test.
parseFile("x = 1; ; x = 2;");
assertContainsError("syntax error at ';'");
}
@Test
public void testDefSingleLine() throws Exception {
List<Statement> statements = parseFileForSkylark(
"def foo(): x = 1; y = 2\n");
FunctionDefStatement stmt = (FunctionDefStatement) statements.get(0);
assertThat(stmt.getStatements()).hasSize(2);
}
@Test
public void testPass() throws Exception {
List<Statement> statements = parseFileForSkylark("pass\n");
assertThat(statements).hasSize(1);
assertThat(statements.get(0)).isInstanceOf(PassStatement.class);
}
@Test
public void testForPass() throws Exception {
List<Statement> statements = parseFileForSkylark(
"def foo():",
" pass\n");
assertThat(statements).hasSize(1);
FunctionDefStatement stmt = (FunctionDefStatement) statements.get(0);
assertThat(stmt.getStatements().get(0)).isInstanceOf(PassStatement.class);
}
@Test
public void testForLoopMultipleVariables() throws Exception {
List<Statement> stmts1 = parseFile("[ i for i, j, k in [(1, 2, 3)] ]\n");
assertThat(stmts1).hasSize(1);
List<Statement> stmts2 = parseFile("[ i for i, j in [(1, 2, 3)] ]\n");
assertThat(stmts2).hasSize(1);
List<Statement> stmts3 = parseFile("[ i for (i, j, k) in [(1, 2, 3)] ]\n");
assertThat(stmts3).hasSize(1);
}
@Test
public void testReturnNone() throws Exception {
List<Statement> defNone = parseFileForSkylark("def foo():", " return None\n");
assertThat(defNone).hasSize(1);
List<Statement> bodyNone = ((FunctionDefStatement) defNone.get(0)).getStatements();
assertThat(bodyNone).hasSize(1);
ReturnStatement returnNone = (ReturnStatement) bodyNone.get(0);
assertThat(((Identifier) returnNone.getReturnExpression()).getName()).isEqualTo("None");
int i = 0;
for (String end : new String[]{";", "\n"}) {
List<Statement> defNoExpr = parseFileForSkylark("def bar" + i + "():", " return" + end);
i++;
assertThat(defNoExpr).hasSize(1);
List<Statement> bodyNoExpr = ((FunctionDefStatement) defNoExpr.get(0)).getStatements();
assertThat(bodyNoExpr).hasSize(1);
ReturnStatement returnNoExpr = (ReturnStatement) bodyNoExpr.get(0);
assertThat(returnNoExpr.getReturnExpression()).isNull();
}
}
@Test
public void testForLoopBadSyntax() throws Exception {
setFailFast(false);
parseFile("[1 for (a, b, c in var]\n");
assertContainsError("syntax error");
}
@Test
public void testForLoopBadSyntax2() throws Exception {
setFailFast(false);
parseFile("[1 for in var]\n");
assertContainsError("syntax error");
}
@Test
public void testFunCallBadSyntax() throws Exception {
setFailFast(false);
parseFile("f(1,\n");
assertContainsError("syntax error");
}
@Test
public void testFunCallBadSyntax2() throws Exception {
setFailFast(false);
parseFile("f(1, 5, ,)\n");
assertContainsError("syntax error");
}
private void validNonAbsoluteImportTest(String importString, String containingFileLabelString,
String expectedLabelString) throws SkylarkImportSyntaxException {
List<Statement> statements =
parseFileForSkylark("load('" + importString + "', 'fun_test')\n");
LoadStatement stmt = (LoadStatement) statements.get(0);
SkylarkImport imp = SkylarkImport.create(stmt.getImport().getValue());
assertWithMessage("getImportString()").that(imp.getImportString()).isEqualTo(importString);
Label containingFileLabel = Label.parseAbsoluteUnchecked(containingFileLabelString);
assertWithMessage("containingFileLabel()")
.that(imp.getLabel(containingFileLabel))
.isEqualTo(Label.parseAbsoluteUnchecked(expectedLabelString));
int startOffset = stmt.getImport().getLocation().getStartOffset();
int endOffset = stmt.getImport().getLocation().getEndOffset();
assertWithMessage("getStartOffset()").that(startOffset).isEqualTo(5);
assertWithMessage("getEndOffset()")
.that(endOffset)
.isEqualTo(startOffset + importString.length() + 2);
}
private void invalidImportTest(String importString, String expectedMsg) {
setFailFast(false);
parseFileForSkylark("load('" + importString + "', 'fun_test')\n");
assertContainsError(expectedMsg);
}
@Test
public void testRelativeImportPathInIsInvalid() throws Exception {
invalidImportTest("file", SkylarkImport.MUST_HAVE_BZL_EXT_MSG);
}
@Test
public void testInvalidRelativePathBzlExtImplicit() throws Exception {
invalidImportTest("file.bzl", SkylarkImport.INVALID_PATH_SYNTAX);
}
@Test
public void testInvalidRelativePathNoSubdirs() throws Exception {
invalidImportTest("path/to/file.bzl", SkylarkImport.INVALID_PATH_SYNTAX);
}
@Test
public void testInvalidRelativePathInvalidFilename() throws Exception {
invalidImportTest("\tfile.bzl", SkylarkImport.INVALID_PATH_SYNTAX);
}
private void validAbsoluteImportLabelTest(String importString)
throws SkylarkImportSyntaxException {
validNonAbsoluteImportTest(importString, /*irrelevant*/ "//another/path:BUILD",
/*expected*/ importString);
}
@Test
public void testValidAbsoluteImportLabel() throws Exception {
validAbsoluteImportLabelTest("//some/skylark:file.bzl");
}
@Test
public void testValidAbsoluteImportLabelWithRepo() throws Exception {
validAbsoluteImportLabelTest("@my_repo//some/skylark:file.bzl");
}
@Test
public void testInvalidAbsoluteImportLabel() throws Exception {
invalidImportTest("//some/skylark/:file.bzl", SkylarkImport.INVALID_LABEL_PREFIX);
}
@Test
public void testInvalidAbsoluteImportLabelWithRepo() throws Exception {
invalidImportTest("@my_repo//some/skylark/:file.bzl", SkylarkImport.INVALID_LABEL_PREFIX);
}
@Test
public void testInvalidAbsoluteImportLabelMissingBzlExt() throws Exception {
invalidImportTest("//some/skylark:file", SkylarkImport.MUST_HAVE_BZL_EXT_MSG);
}
@Test
public void testInvalidAbsoluteImportReferencesExternalPkg() throws Exception {
invalidImportTest("//external:file.bzl", SkylarkImport.EXTERNAL_PKG_NOT_ALLOWED_MSG);
}
@Test
public void testValidRelativeImportSimpleLabelInPackageDir() throws Exception {
validNonAbsoluteImportTest(":file.bzl", /*containing*/ "//some/skylark:BUILD",
/*expected*/ "//some/skylark:file.bzl");
}
@Test
public void testValidRelativeImportSimpleLabelInPackageSubdir() throws Exception {
validNonAbsoluteImportTest(":file.bzl", /*containing*/ "//some/path/to:skylark/parent.bzl",
/*expected*/ "//some/path/to:file.bzl");
}
@Test
public void testValidRelativeImportComplexLabelInPackageDir() throws Exception {
validNonAbsoluteImportTest(":subdir/containing/file.bzl", /*containing*/ "//some/skylark:BUILD",
/*expected*/ "//some/skylark:subdir/containing/file.bzl");
}
@Test
public void testValidRelativeImportComplexLabelInPackageSubdir() throws Exception {
validNonAbsoluteImportTest(":subdir/containing/file.bzl",
/*containing*/ "//some/path/to:skylark/parent.bzl",
/*expected*/ "//some/path/to:subdir/containing/file.bzl");
}
@Test
public void testInvalidRelativeImportLabelMissingBzlExt() throws Exception {
invalidImportTest(":file", SkylarkImport.MUST_HAVE_BZL_EXT_MSG);
}
@Test
public void testInvalidRelativeImportLabelSyntax() throws Exception {
invalidImportTest("::file.bzl", SkylarkImport.INVALID_TARGET_PREFIX);
}
@Test
public void testLoadNoSymbol() throws Exception {
setFailFast(false);
parseFileForSkylark("load('//foo/bar:file.bzl')\n");
assertContainsError("expected at least one symbol to load");
}
@Test
public void testLoadOneSymbol() throws Exception {
List<Statement> statements = parseFileForSkylark("load('//foo/bar:file.bzl', 'fun_test')\n");
LoadStatement stmt = (LoadStatement) statements.get(0);
assertThat(stmt.getImport().getValue()).isEqualTo("//foo/bar:file.bzl");
assertThat(stmt.getBindings()).hasSize(1);
Identifier sym = stmt.getBindings().get(0).getLocalName();
int startOffset = sym.getLocation().getStartOffset();
int endOffset = sym.getLocation().getEndOffset();
assertWithMessage("getStartOffset()").that(startOffset).isEqualTo(27);
assertWithMessage("getEndOffset()").that(endOffset).isEqualTo(startOffset + 10);
}
@Test
public void testLoadOneSymbolWithTrailingComma() throws Exception {
List<Statement> statements = parseFileForSkylark("load('//foo/bar:file.bzl', 'fun_test',)\n");
LoadStatement stmt = (LoadStatement) statements.get(0);
assertThat(stmt.getImport().getValue()).isEqualTo("//foo/bar:file.bzl");
assertThat(stmt.getBindings()).hasSize(1);
}
@Test
public void testLoadMultipleSymbols() throws Exception {
List<Statement> statements = parseFileForSkylark("load(':file.bzl', 'foo', 'bar')\n");
LoadStatement stmt = (LoadStatement) statements.get(0);
assertThat(stmt.getImport().getValue()).isEqualTo(":file.bzl");
assertThat(stmt.getBindings()).hasSize(2);
}
@Test
public void testLoadLabelQuoteError() throws Exception {
setFailFast(false);
parseFileForSkylark("load(non_quoted, 'a')\n");
assertContainsError("syntax error");
}
@Test
public void testLoadSymbolQuoteError() throws Exception {
setFailFast(false);
parseFileForSkylark("load('label', non_quoted)\n");
assertContainsError("syntax error");
}
@Test
public void testLoadDisallowSameLine() throws Exception {
setFailFast(false);
parseFileForSkylark("load('foo.bzl', 'foo') load('bar.bzl', 'bar')");
assertContainsError("syntax error");
}
@Test
public void testLoadNotAtTopLevel() throws Exception {
setFailFast(false);
parseFileForSkylark("if 1: load(8)\n");
assertContainsError("syntax error at 'load': expected expression");
}
@Test
public void testLoadAlias() throws Exception {
List<Statement> statements =
parseFileForSkylark("load('//foo/bar:file.bzl', my_alias = 'lawl')\n");
LoadStatement stmt = (LoadStatement) statements.get(0);
ImmutableList<LoadStatement.Binding> actualSymbols = stmt.getBindings();
assertThat(actualSymbols).hasSize(1);
Identifier sym = actualSymbols.get(0).getLocalName();
assertThat(sym.getName()).isEqualTo("my_alias");
int startOffset = sym.getLocation().getStartOffset();
int endOffset = sym.getLocation().getEndOffset();
assertWithMessage("getStartOffset()").that(startOffset).isEqualTo(27);
assertWithMessage("getEndOffset()").that(endOffset).isEqualTo(startOffset + 8);
}
@Test
public void testLoadAliasMultiple() throws Exception {
runLoadAliasTestForSymbols(
"my_alias = 'lawl', 'lol', next_alias = 'rofl'", "my_alias", "lol", "next_alias");
}
private void runLoadAliasTestForSymbols(String loadSymbolString, String... expectedSymbols) {
List<Statement> statements =
parseFileForSkylark(String.format("load('//foo/bar:file.bzl', %s)\n", loadSymbolString));
LoadStatement stmt = (LoadStatement) statements.get(0);
ImmutableList<LoadStatement.Binding> actualSymbols = stmt.getBindings();
assertThat(actualSymbols).hasSize(expectedSymbols.length);
List<String> actualSymbolNames = new LinkedList<>();
for (LoadStatement.Binding binding : actualSymbols) {
actualSymbolNames.add(binding.getLocalName().getName());
}
assertThat(actualSymbolNames).containsExactly((Object[]) expectedSymbols);
}
@Test
public void testLoadAliasSyntaxError() throws Exception {
setFailFast(false);
parseFileForSkylark("load('//foo:bzl', test1 = )\n");
assertContainsError("syntax error at ')': expected string");
parseFileForSkylark("load(':foo.bzl', test2 = 1)\n");
assertContainsError("syntax error at '1': expected string");
parseFileForSkylark("load(':foo.bzl', test3 = old)\n");
assertContainsError("syntax error at 'old': expected string");
}
@Test
public void testParseErrorNotComparison() throws Exception {
setFailFast(false);
parseFile("2 < not 3");
assertContainsError("syntax error at 'not'");
}
@Test
public void testNotWithArithmeticOperatorsBadSyntax() throws Exception {
setFailFast(false);
parseFile("0 + not 0");
assertContainsError("syntax error at 'not'");
}
@Test
public void testOptionalArgBeforeMandatoryArgInFuncDef() throws Exception {
setFailFast(false);
parseFileForSkylark("def func(a, b = 'a', c):\n return 0\n");
assertContainsError(
"a mandatory positional parameter must not follow an optional parameter");
}
@Test
public void testKwargBeforePositionalArg() throws Exception {
setFailFast(false);
parseFileForSkylark(
"def func(a, b): return a + b",
"func(**{'b': 1}, 'a')");
assertContainsError("unexpected tokens after kwarg");
}
@Test
public void testDuplicateKwarg() throws Exception {
setFailFast(false);
parseFileForSkylark(
"def func(a, b): return a + b",
"func(**{'b': 1}, **{'a': 2})");
assertContainsError("unexpected tokens after kwarg");
}
@Test
public void testUnnamedStar() throws Exception {
setFailFast(false);
List<Statement> statements = parseFileForSkylark(
"def func(a, b1=2, b2=3, *, c1, d=4, c2): return a + b1 + b2 + c1 + c2 + d\n");
assertThat(statements).hasSize(1);
assertThat(statements.get(0)).isInstanceOf(FunctionDefStatement.class);
FunctionDefStatement stmt = (FunctionDefStatement) statements.get(0);
FunctionSignature sig = stmt.getSignature().getSignature();
// Note the reordering of optional named-only at the end.
assertThat(sig.getNames()).isEqualTo(ImmutableList.<String>of(
"a", "b1", "b2", "c1", "c2", "d"));
FunctionSignature.Shape shape = sig.getShape();
assertThat(shape.getMandatoryPositionals()).isEqualTo(1);
assertThat(shape.getOptionalPositionals()).isEqualTo(2);
assertThat(shape.getMandatoryNamedOnly()).isEqualTo(2);
assertThat(shape.getOptionalNamedOnly()).isEqualTo(1);
}
@Test
public void testTopLevelForFails() throws Exception {
setFailFast(false);
parseFileForSkylark("for i in []: 0\n");
assertContainsError(
"for loops are not allowed on top-level. Put it into a function");
}
@Test
public void testNestedFunctionFails() throws Exception {
setFailFast(false);
parseFileForSkylark(
"def func(a):",
" def bar(): return 0",
" return bar()",
"");
assertContainsError(
"nested functions are not allowed. Move the function to top-level");
}
@Test
public void testElseWithoutIf() throws Exception {
setFailFast(false);
parseFileForSkylark(
"def func(a):",
// no if
" else: return a");
assertContainsError("syntax error at 'else': expected expression");
}
@Test
public void testForElse() throws Exception {
setFailFast(false);
parseFileForSkylark(
"def func(a):",
" for i in range(a):",
" print(i)",
" else: return a");
assertContainsError("syntax error at 'else': expected expression");
}
@Test
public void testTryStatementInBuild() throws Exception {
setFailFast(false);
parseFile("try: pass");
assertContainsError("'try' not supported, all exceptions are fatal");
}
@Test
public void testClassDefinitionInBuild() throws Exception {
setFailFast(false);
parseFileWithComments("class test(object): pass");
assertContainsError("keyword 'class' not supported");
}
@Test
public void testClassDefinitionInSkylark() throws Exception {
setFailFast(false);
parseFileForSkylark("class test(object): pass");
assertContainsError("keyword 'class' not supported");
}
@Test
public void testArgumentAfterKwargs() throws Exception {
setFailFast(false);
parseFileForSkylark(
"f(",
" 1,",
" *[2],",
" *[3],", // error on this line
")\n");
assertContainsError(":4:5: *arg argument is misplaced");
}
@Test
public void testPositionalArgAfterKeywordArg() throws Exception {
setFailFast(false);
parseFileForSkylark(
"f(",
" 2,",
" a = 4,",
" 3,", // error on this line
")\n");
assertContainsError(":4:5: positional argument is misplaced (positional arguments come first)");
}
@Test
public void testStringsAreDeduped() throws Exception {
BuildFileAST buildFileAST =
parseFileForSkylarkAsAST("L1 = ['cat', 'dog', 'fish']", "L2 = ['dog', 'fish', 'cat']");
Set<String> uniqueStringInstances = Sets.newIdentityHashSet();
SyntaxTreeVisitor collectAllStringsInStringLiteralsVisitor =
new SyntaxTreeVisitor() {
@Override
public void visit(StringLiteral stringLiteral) {
uniqueStringInstances.add(stringLiteral.getValue());
}
};
collectAllStringsInStringLiteralsVisitor.visit(buildFileAST);
assertThat(uniqueStringInstances).containsExactly("cat", "dog", "fish");
}
}