starlark syntax: parse big integers
Integer literals outside the signed 32-bit range are now treated
as a dynamic, not static, error. CL 333467651 will add support for
bigint values; a further follow-up will remove the dynamic error.
Also:
- rename IntegerLiteral to IntLiteral, to use preferred Starlark term.
- expose IntLiteral.scan, and clean it up, including error message tweaks.
PiperOrigin-RevId: 334669391
diff --git a/src/main/java/com/google/devtools/build/lib/packages/PackageFactory.java b/src/main/java/com/google/devtools/build/lib/packages/PackageFactory.java
index d12dde8..dfe6921 100644
--- a/src/main/java/com/google/devtools/build/lib/packages/PackageFactory.java
+++ b/src/main/java/com/google/devtools/build/lib/packages/PackageFactory.java
@@ -81,7 +81,7 @@
import net.starlark.java.syntax.ForStatement;
import net.starlark.java.syntax.Identifier;
import net.starlark.java.syntax.IfStatement;
-import net.starlark.java.syntax.IntegerLiteral;
+import net.starlark.java.syntax.IntLiteral;
import net.starlark.java.syntax.ListExpression;
import net.starlark.java.syntax.Location;
import net.starlark.java.syntax.NodeVisitor;
@@ -1163,9 +1163,11 @@
String pattern = ((StringLiteral) elem).getValue();
// exclude_directories is (oddly) an int with default 1.
boolean exclude = true;
- if (excludeDirectories instanceof IntegerLiteral
- && ((IntegerLiteral) excludeDirectories).getValue() == 0) {
- exclude = false;
+ if (excludeDirectories instanceof IntLiteral) {
+ Number v = ((IntLiteral) excludeDirectories).getValue();
+ if (v instanceof Integer && (Integer) v == 0) {
+ exclude = false;
+ }
}
(exclude ? globs : globsWithDirs).add(pattern);
}
diff --git a/src/main/java/net/starlark/java/eval/Eval.java b/src/main/java/net/starlark/java/eval/Eval.java
index 2791b9c..14a8b87 100644
--- a/src/main/java/net/starlark/java/eval/Eval.java
+++ b/src/main/java/net/starlark/java/eval/Eval.java
@@ -16,6 +16,7 @@
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
+import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
@@ -38,7 +39,7 @@
import net.starlark.java.syntax.Identifier;
import net.starlark.java.syntax.IfStatement;
import net.starlark.java.syntax.IndexExpression;
-import net.starlark.java.syntax.IntegerLiteral;
+import net.starlark.java.syntax.IntLiteral;
import net.starlark.java.syntax.ListExpression;
import net.starlark.java.syntax.LoadStatement;
import net.starlark.java.syntax.Location;
@@ -448,11 +449,18 @@
return evalIdentifier(fr, (Identifier) expr);
case INDEX:
return evalIndex(fr, (IndexExpression) expr);
- case INTEGER_LITERAL:
+ case INT_LITERAL:
// TODO(adonovan): opt: avoid allocation by saving
- // the StarlarkInt in the IntegerLiteral (a temporary hack
+ // the StarlarkInt in the IntLiteral (a temporary hack
// until we use a compiled representation).
- return StarlarkInt.of(((IntegerLiteral) expr).getValue());
+ Number n = ((IntLiteral) expr).getValue();
+ if (n instanceof Integer) {
+ return StarlarkInt.of((Integer) n);
+ } else if (n instanceof Long) {
+ return StarlarkInt.of((Long) n);
+ } else {
+ return StarlarkInt.of((BigInteger) n);
+ }
case LIST_EXPR:
return evalList(fr, (ListExpression) expr);
case SLICE:
diff --git a/src/main/java/net/starlark/java/syntax/BUILD b/src/main/java/net/starlark/java/syntax/BUILD
index 28ec45f..8535a63 100644
--- a/src/main/java/net/starlark/java/syntax/BUILD
+++ b/src/main/java/net/starlark/java/syntax/BUILD
@@ -33,7 +33,7 @@
"Identifier.java",
"IfStatement.java",
"IndexExpression.java",
- "IntegerLiteral.java",
+ "IntLiteral.java",
"Lexer.java",
"ListExpression.java",
"LoadStatement.java",
diff --git a/src/main/java/net/starlark/java/syntax/Expression.java b/src/main/java/net/starlark/java/syntax/Expression.java
index f56c138..4db3ff7 100644
--- a/src/main/java/net/starlark/java/syntax/Expression.java
+++ b/src/main/java/net/starlark/java/syntax/Expression.java
@@ -37,7 +37,7 @@
CALL,
IDENTIFIER,
INDEX,
- INTEGER_LITERAL,
+ INT_LITERAL,
LIST_EXPR,
SLICE,
STRING_LITERAL,
diff --git a/src/main/java/net/starlark/java/syntax/IntLiteral.java b/src/main/java/net/starlark/java/syntax/IntLiteral.java
new file mode 100644
index 0000000..f281151
--- /dev/null
+++ b/src/main/java/net/starlark/java/syntax/IntLiteral.java
@@ -0,0 +1,107 @@
+// 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 net.starlark.java.syntax;
+
+import java.math.BigInteger;
+
+/** Syntax node for an int literal. */
+public final class IntLiteral extends Expression {
+ private final String raw;
+ private final int tokenOffset;
+ private final Number value; // = Integer | Long | BigInteger
+
+ IntLiteral(FileLocations locs, String raw, int tokenOffset, Number value) {
+ super(locs);
+ this.raw = raw;
+ this.tokenOffset = tokenOffset;
+ this.value = value;
+ }
+
+ /**
+ * Returns the value denoted by this literal as an Integer, Long, or BigInteger, using the
+ * narrowest type capable of exactly representing the value.
+ */
+ public Number getValue() {
+ return value;
+ }
+
+ /** Returns the raw source text of the literal. */
+ public String getRaw() {
+ return raw;
+ }
+
+ @Override
+ public int getStartOffset() {
+ return tokenOffset;
+ }
+
+ @Override
+ public int getEndOffset() {
+ return tokenOffset + raw.length();
+ }
+
+ @Override
+ public void accept(NodeVisitor visitor) {
+ visitor.visit(this);
+ }
+
+ @Override
+ public Kind kind() {
+ return Kind.INT_LITERAL;
+ }
+
+ /**
+ * Returns the value denoted by a non-negative integer literal with an optional base prefix (but
+ * no +/- sign), using the narrowest type of Integer, Long, or BigInteger capable of exactly
+ * representing the value.
+ *
+ * @throws NumberFormatException if the string is not a valid literal.
+ */
+ public static Number scan(String str) {
+ String orig = str;
+ int radix = 10;
+ if (str.length() > 1 && str.charAt(0) == '0') {
+ switch (str.charAt(1)) {
+ case 'x':
+ case 'X':
+ radix = 16;
+ str = str.substring(2);
+ break;
+ case 'o':
+ case 'O':
+ radix = 8;
+ str = str.substring(2);
+ break;
+ default:
+ throw new NumberFormatException(
+ "invalid octal literal: " + str + " (use '0o" + str.substring(1) + "')");
+ }
+ }
+
+ try {
+ long v = Long.parseLong(str, radix);
+ if (v == (int) v) {
+ return (int) v;
+ }
+ return v;
+ } catch (NumberFormatException unused) {
+ /* fall through */
+ }
+ try {
+ return new BigInteger(str, radix);
+ } catch (NumberFormatException unused) {
+ throw new NumberFormatException("invalid base-" + radix + " integer literal: " + orig);
+ }
+ }
+}
diff --git a/src/main/java/net/starlark/java/syntax/IntegerLiteral.java b/src/main/java/net/starlark/java/syntax/IntegerLiteral.java
deleted file mode 100644
index 313e06c..0000000
--- a/src/main/java/net/starlark/java/syntax/IntegerLiteral.java
+++ /dev/null
@@ -1,58 +0,0 @@
-// 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 net.starlark.java.syntax;
-
-/** Syntax node for an integer literal. */
-// TODO(adonovan): support literals of arbitrary size.
-public final class IntegerLiteral extends Expression {
- private final String raw;
- private final int tokenOffset;
- private final int value;
-
- IntegerLiteral(FileLocations locs, String raw, int tokenOffset, int value) {
- super(locs);
- this.raw = raw;
- this.tokenOffset = tokenOffset;
- this.value = value;
- }
-
- public int getValue() {
- return value;
- }
-
- /** Returns the raw source text of the literal. */
- public String getRaw() {
- return raw;
- }
-
- @Override
- public int getStartOffset() {
- return tokenOffset;
- }
-
- @Override
- public int getEndOffset() {
- return tokenOffset + raw.length();
- }
-
- @Override
- public void accept(NodeVisitor visitor) {
- visitor.visit(this);
- }
-
- @Override
- public Kind kind() {
- return Kind.INTEGER_LITERAL;
- }
-}
diff --git a/src/main/java/net/starlark/java/syntax/Lexer.java b/src/main/java/net/starlark/java/syntax/Lexer.java
index 9113ee5..e957c46 100644
--- a/src/main/java/net/starlark/java/syntax/Lexer.java
+++ b/src/main/java/net/starlark/java/syntax/Lexer.java
@@ -37,7 +37,7 @@
int start; // start offset
int end; // end offset
String raw; // source text of token
- Object value; // String or Integer value of token
+ Object value; // String or Integer/Long/BigInteger value of token
// --- end of parser-visible fields ---
@@ -591,28 +591,12 @@
int oldPos = pos - 1;
String literal = scanInteger();
- final String substring;
- final int radix;
- if (literal.startsWith("0x") || literal.startsWith("0X")) {
- radix = 16;
- substring = literal.substring(2);
- } else if (literal.startsWith("0o") || literal.startsWith("0O")) {
- radix = 8;
- substring = literal.substring(2);
- } else if (literal.startsWith("0") && literal.length() > 1) {
- radix = 8;
- substring = literal.substring(1);
- error("invalid octal value `" + literal + "`, should be: `0o" + substring + "`", oldPos);
- } else {
- radix = 10;
- substring = literal;
- }
-
- int value = 0;
+ Number value;
try {
- value = Integer.parseInt(substring, radix);
- } catch (NumberFormatException e) {
- error("invalid base-" + radix + " integer constant: " + literal, oldPos);
+ value = IntLiteral.scan(literal);
+ } catch (NumberFormatException ex) {
+ error(ex.getMessage(), oldPos);
+ value = 0;
}
setToken(TokenKind.INT, oldPos, pos);
diff --git a/src/main/java/net/starlark/java/syntax/NodePrinter.java b/src/main/java/net/starlark/java/syntax/NodePrinter.java
index 98dc8c0..5a68072 100644
--- a/src/main/java/net/starlark/java/syntax/NodePrinter.java
+++ b/src/main/java/net/starlark/java/syntax/NodePrinter.java
@@ -356,9 +356,9 @@
break;
}
- case INTEGER_LITERAL:
+ case INT_LITERAL:
{
- buf.append(((IntegerLiteral) expr).getValue());
+ buf.append(((IntLiteral) expr).getValue());
break;
}
diff --git a/src/main/java/net/starlark/java/syntax/NodeVisitor.java b/src/main/java/net/starlark/java/syntax/NodeVisitor.java
index 22396fe..1af2275 100644
--- a/src/main/java/net/starlark/java/syntax/NodeVisitor.java
+++ b/src/main/java/net/starlark/java/syntax/NodeVisitor.java
@@ -110,7 +110,7 @@
visitAll(node.getElements());
}
- public void visit(@SuppressWarnings("unused") IntegerLiteral node) {}
+ public void visit(@SuppressWarnings("unused") IntLiteral node) {}
public void visit(@SuppressWarnings("unused") StringLiteral node) {}
diff --git a/src/main/java/net/starlark/java/syntax/Parser.java b/src/main/java/net/starlark/java/syntax/Parser.java
index 4e72318..f375025 100644
--- a/src/main/java/net/starlark/java/syntax/Parser.java
+++ b/src/main/java/net/starlark/java/syntax/Parser.java
@@ -572,8 +572,7 @@
switch (token.kind) {
case INT:
{
- IntegerLiteral literal =
- new IntegerLiteral(locs, token.raw, token.start, (Integer) token.value);
+ IntLiteral literal = new IntLiteral(locs, token.raw, token.start, (Number) token.value);
nextToken();
return literal;
}
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 e6b1680..59e517b 100644
--- a/src/test/java/net/starlark/java/eval/testdata/int.sky
+++ b/src/test/java/net/starlark/java/eval/testdata/int.sky
@@ -7,12 +7,13 @@
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"
+# big numbers
+assert_eq(+1 << 32, +0x100000000)
+assert_eq(-1 << 32, -0x100000000)
+assert_eq(+1 << 64, +0x10000000000000000)
+assert_eq(-1 << 64, -0x10000000000000000)
+assert_eq(+1 << 128, +0x100000000000000000000000000000000)
+assert_eq(-1 << 128, -0x100000000000000000000000000000000)
assert_eq((1 << 128) // (1 << 127), 2)
# size boundaries
@@ -20,10 +21,10 @@
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")
+assert_eq(maxint + 1, 0x80000000)
+assert_eq(maxlong + 1, 0x8000000000000000)
+assert_eq(minint - 1, -0x80000001)
+assert_eq(minlong - 1, -0x8000000000000001)
# str(int)
assert_eq(str(0), "0")
@@ -35,6 +36,13 @@
assert_eq(str(-1<<48), "-281474976710656")
assert_eq(str(-1<<96), "-79228162514264337593543950336")
+# %d formatting
+# TODO(adonovan): implement %x.
+assert_eq("%d" % (1 << 32), "4294967296")
+assert_eq("%d" % (1 << 64), "18446744073709551616")
+assert_eq("%d" % (1 << 128), "340282366920938463463374607431768211456")
+assert_eq("%d" % (-1 << 128), "-340282366920938463463374607431768211456")
+
# truth
assert_(not 0)
assert_(1)
@@ -69,12 +77,11 @@
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")
+assert_eq(maxint * maxint, 0x3fffffff00000001)
+assert_eq((1<<62) - (2<<31) + 1, 0x3fffffff00000001)
+assert_eq(111111111 * 111111111, 12345678987654321)
+assert_eq(-(111111111 * 111111111), -12345678987654321)
+assert_eq((111111111 * 111111111) // 111111111, 111111111)
# division
assert_eq(100 // 7, 14)
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 abd5861..840b430 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
@@ -5,14 +5,9 @@
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
----
+assert_eq(int(-2147483647 - 1), -2147483648)
+assert_eq(int(-2147483649), -2147483649)
+assert_eq(int(1 << 100), 1 << 100)
# from bool
assert_eq(int(True), 1)
@@ -33,15 +28,15 @@
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('123456789012345678901234567891234567890'), 123456789012345678901234567891234567890)
+assert_eq(int('-123456789012345678901234567891234567890'), -123456789012345678901234567891234567890)
+assert_eq(int('-0xabcdefabcdefabcdefabcdefabcdef', 0), -0xabcdefabcdefabcdefabcdefabcdef)
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('1111111111111', 5), 305175781)
+assert_eq(int('1111111111111', 8), 78536544841)
+assert_eq(int('1111111111111', 10), 1111111111111)
+assert_eq(int('1111111111111', 16), 300239975158033)
+assert_eq(int('1111111111111', 36), 4873763662273663093)
assert_eq(int('016'), 16) # zero ok when base != 0.
assert_eq(int('+42'), 42) # '+' prefix ok
# with base, no prefix
diff --git a/src/test/java/net/starlark/java/syntax/LexerTest.java b/src/test/java/net/starlark/java/syntax/LexerTest.java
index bc5e209..de6c909 100644
--- a/src/test/java/net/starlark/java/syntax/LexerTest.java
+++ b/src/test/java/net/starlark/java/syntax/LexerTest.java
@@ -192,7 +192,7 @@
.isEqualTo("INT IN LPAREN STRING AND LBRACKET RBRACKET RPAREN NEWLINE EOF");
assertThat(values(tokens("0or()"))).isEqualTo("INT(0) IDENTIFIER(r) LPAREN RPAREN NEWLINE EOF");
- assertThat(lastError).isEqualTo("/some/path.txt:1: invalid base-8 integer constant: 0o");
+ assertThat(lastError).isEqualTo("/some/path.txt:1: invalid base-8 integer literal: 0o");
}
@Test
@@ -223,17 +223,17 @@
assertThat(values(tokens("0O77"))).isEqualTo("INT(63) NEWLINE EOF");
// octal (bad)
- assertThat(values(tokens("012349-"))).isEqualTo("INT(0) MINUS NEWLINE EOF");
+ assertThat(values(tokens("0o12349-"))).isEqualTo("INT(0) MINUS NEWLINE EOF");
assertThat(lastError.toString())
- .isEqualTo("/some/path.txt:1: invalid base-8 integer constant: 012349");
+ .isEqualTo("/some/path.txt:1: invalid base-8 integer literal: 0o12349");
assertThat(values(tokens("0o"))).isEqualTo("INT(0) NEWLINE EOF");
assertThat(lastError.toString())
- .isEqualTo("/some/path.txt:1: invalid base-8 integer constant: 0o");
+ .isEqualTo("/some/path.txt:1: invalid base-8 integer literal: 0o");
- assertThat(values(tokens("012345"))).isEqualTo("INT(5349) NEWLINE EOF");
+ assertThat(values(tokens("012345"))).isEqualTo("INT(0) NEWLINE EOF");
assertThat(lastError.toString())
- .isEqualTo("/some/path.txt:1: invalid octal value `012345`, should be: `0o12345`");
+ .isEqualTo("/some/path.txt:1: invalid octal literal: 012345 (use '0o12345')");
// hexadecimal (uppercase)
assertThat(values(tokens("0X12345F-"))).isEqualTo("INT(1193055) MINUS NEWLINE EOF");
@@ -243,6 +243,15 @@
// hexadecimal (lowercase) [note: "g" cause termination of token]
assertThat(values(tokens("0x12345g-"))).isEqualTo("INT(74565) IDENTIFIER(g) MINUS NEWLINE EOF");
+
+ // long
+ assertThat(values(tokens("1234567890 0x123456789ABCDEF")))
+ .isEqualTo("INT(1234567890) INT(81985529216486895) NEWLINE EOF");
+ // big
+ assertThat(values(tokens("123456789123456789123456789 0xABCDEFABCDEFABCDEFABCDEFABCDEF")))
+ .isEqualTo(
+ "INT(123456789123456789123456789) INT(892059645479943313385225296292859375) NEWLINE"
+ + " EOF");
}
@Test
@@ -251,13 +260,14 @@
assertThat(values(tokens("1.2.345"))).isEqualTo("INT(1) DOT INT(2) DOT INT(345) NEWLINE EOF");
+ // TODO(adonovan): parse floating point numbers.
assertThat(values(tokens("1.0E10"))).isEqualTo("INT(1) DOT INT(0) NEWLINE EOF");
assertThat(lastError.toString())
- .isEqualTo("/some/path.txt:1: invalid base-8 integer constant: 0E10");
+ .isEqualTo("/some/path.txt:1: invalid octal literal: 0E10 (use '0oE10')");
assertThat(values(tokens("1.03E-10"))).isEqualTo("INT(1) DOT INT(0) MINUS INT(10) NEWLINE EOF");
assertThat(lastError.toString())
- .isEqualTo("/some/path.txt:1: invalid base-8 integer constant: 03E");
+ .isEqualTo("/some/path.txt:1: invalid octal literal: 03E (use '0o3E')");
assertThat(values(tokens(". 123"))).isEqualTo("DOT INT(123) NEWLINE EOF");
assertThat(values(tokens(".123"))).isEqualTo("DOT INT(123) NEWLINE EOF");
diff --git a/src/test/java/net/starlark/java/syntax/ParserTest.java b/src/test/java/net/starlark/java/syntax/ParserTest.java
index 951036c..33560c1 100644
--- a/src/test/java/net/starlark/java/syntax/ParserTest.java
+++ b/src/test/java/net/starlark/java/syntax/ParserTest.java
@@ -101,13 +101,13 @@
}
// helper func for testListExpressions:
- private static int getIntElem(DictExpression.Entry entry, boolean key) {
- return ((IntegerLiteral) (key ? entry.getKey() : entry.getValue())).getValue();
+ private static Number getIntElem(DictExpression.Entry entry, boolean key) {
+ return ((IntLiteral) (key ? entry.getKey() : entry.getValue())).getValue();
}
// helper func for testListExpressions:
- private static int getIntElem(ListExpression list, int index) {
- return ((IntegerLiteral) list.getElements().get(index)).getValue();
+ private static Number getIntElem(ListExpression list, int index) {
+ return ((IntLiteral) list.getElements().get(index)).getValue();
}
// helper func for testListExpressions:
@@ -186,9 +186,9 @@
UnaryOperatorExpression e = (UnaryOperatorExpression) parseExpression("-5");
UnaryOperatorExpression e2 = (UnaryOperatorExpression) parseExpression("- 5");
- IntegerLiteral i = (IntegerLiteral) e.getX();
+ IntLiteral i = (IntLiteral) e.getX();
assertThat(i.getValue()).isEqualTo(5);
- IntegerLiteral i2 = (IntegerLiteral) e2.getX();
+ IntLiteral i2 = (IntLiteral) e2.getX();
assertThat(i2.getValue()).isEqualTo(5);
assertLocation(0, 2, e);
assertLocation(0, 3, e2);
@@ -201,16 +201,16 @@
IndexExpression function = (IndexExpression) e.getFunction();
Identifier functionList = (Identifier) function.getObject();
assertThat(functionList.getName()).isEqualTo("foo");
- IntegerLiteral listIndex = (IntegerLiteral) function.getKey();
+ IntLiteral listIndex = (IntLiteral) 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();
+ IntLiteral arg0 = (IntLiteral) e.getArguments().get(0).getValue();
assertThat((int) arg0.getValue()).isEqualTo(1);
- IntegerLiteral arg1 = (IntegerLiteral) e.getArguments().get(1).getValue();
+ IntLiteral arg1 = (IntLiteral) e.getArguments().get(1).getValue();
assertThat((int) arg1.getValue()).isEqualTo(2);
Argument arg2 = e.getArguments().get(2);
@@ -229,10 +229,10 @@
assertThat(e.getArguments()).hasSize(3);
assertThat(e.getNumPositionalArguments()).isEqualTo(2);
- IntegerLiteral arg0 = (IntegerLiteral) e.getArguments().get(0).getValue();
+ IntLiteral arg0 = (IntLiteral) e.getArguments().get(0).getValue();
assertThat((int) arg0.getValue()).isEqualTo(1);
- IntegerLiteral arg1 = (IntegerLiteral) e.getArguments().get(1).getValue();
+ IntLiteral arg1 = (IntLiteral) e.getArguments().get(1).getValue();
assertThat((int) arg1.getValue()).isEqualTo(2);
Argument arg2 = e.getArguments().get(2);
@@ -251,7 +251,7 @@
assertThat(e.getArguments()).hasSize(1);
assertThat(e.getNumPositionalArguments()).isEqualTo(1);
- IntegerLiteral arg0 = (IntegerLiteral) e.getArguments().get(0).getValue();
+ IntLiteral arg0 = (IntLiteral) e.getArguments().get(0).getValue();
assertThat((int) arg0.getValue()).isEqualTo(1);
}
@@ -310,7 +310,7 @@
@Test
public void testSubstring() throws Exception {
SliceExpression s = (SliceExpression) parseExpression("'FOO.CC'[:].lower()[1:]");
- assertThat(((IntegerLiteral) s.getStart()).getValue()).isEqualTo(1);
+ assertThat(((IntLiteral) s.getStart()).getValue()).isEqualTo(1);
CallExpression e = (CallExpression) parseExpression("'FOO.CC'.lower()[1:].startswith('oo')");
DotExpression dotExpression = (DotExpression) e.getFunction();
@@ -318,7 +318,7 @@
assertThat(e.getArguments()).hasSize(1);
s = (SliceExpression) parseExpression("'FOO.CC'[1:][:2]");
- assertThat(((IntegerLiteral) s.getStop()).getValue()).isEqualTo(2);
+ assertThat(((IntLiteral) s.getStop()).getValue()).isEqualTo(2);
}
@Test
@@ -372,7 +372,7 @@
assertThat(e.getArguments()).hasSize(3);
assertThat(e.getNumPositionalArguments()).isEqualTo(3);
- IntegerLiteral arg0 = (IntegerLiteral) e.getArguments().get(0).getValue();
+ IntLiteral arg0 = (IntLiteral) e.getArguments().get(0).getValue();
assertThat((int) arg0.getValue()).isEqualTo(1);
Argument arg1 = e.getArguments().get(1);
@@ -383,7 +383,7 @@
assertThat(src.substring(5, 28)).isEqualTo("[x for foo foo foo foo]");
assertThat(arg1val.getEndLocation().column()).isEqualTo(29);
- IntegerLiteral arg2 = (IntegerLiteral) e.getArguments().get(2).getValue();
+ IntLiteral arg2 = (IntLiteral) e.getArguments().get(2).getValue();
assertThat((int) arg2.getValue()).isEqualTo(3);
}
@@ -727,7 +727,7 @@
@Test
public void testTupleLiterals5() throws Exception {
- IntegerLiteral intLit = (IntegerLiteral) parseExpression("(42)"); // not a tuple!
+ IntLiteral intLit = (IntLiteral) parseExpression("(42)"); // not a tuple!
assertThat((int) intLit.getValue()).isEqualTo(42);
}
