Automated cleanup
--
MOS_MIGRATED_REVID=135816105
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/AbstractComprehension.java b/src/main/java/com/google/devtools/build/lib/syntax/AbstractComprehension.java
index 17777e8..c5bb91b 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/AbstractComprehension.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/AbstractComprehension.java
@@ -27,18 +27,15 @@
import com.google.devtools.build.lib.syntax.compiler.LabelAdder;
import com.google.devtools.build.lib.syntax.compiler.Variable.InternalVariable;
import com.google.devtools.build.lib.syntax.compiler.VariableScope;
-
-import net.bytebuddy.description.type.TypeDescription;
-import net.bytebuddy.implementation.bytecode.ByteCodeAppender;
-
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
-
import javax.annotation.Nullable;
+import net.bytebuddy.description.type.TypeDescription;
+import net.bytebuddy.implementation.bytecode.ByteCodeAppender;
/**
* Base class for list and dict comprehension expressions.
@@ -284,7 +281,7 @@
StringBuilder sb = new StringBuilder();
sb.append(openingBracket).append(printExpressions());
for (Clause clause : clauses) {
- sb.append(' ').append(clause.toString());
+ sb.append(' ').append(clause);
}
sb.append(closingBracket);
return sb.toString();
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/BaseFunction.java b/src/main/java/com/google/devtools/build/lib/syntax/BaseFunction.java
index 942bf92..f836704 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/BaseFunction.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/BaseFunction.java
@@ -22,18 +22,14 @@
import com.google.devtools.build.lib.skylarkinterface.SkylarkSignature;
import com.google.devtools.build.lib.skylarkinterface.SkylarkValue;
import com.google.devtools.build.lib.syntax.SkylarkList.Tuple;
-import com.google.devtools.build.lib.syntax.Type.ConversionException;
import com.google.devtools.build.lib.syntax.compiler.ByteCodeUtils;
import com.google.devtools.build.lib.util.Preconditions;
-
-import net.bytebuddy.implementation.bytecode.StackManipulation;
-
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
-
import javax.annotation.Nullable;
+import net.bytebuddy.implementation.bytecode.StackManipulation;
/**
* A base class for Skylark functions, whether builtin or user-defined.
@@ -444,8 +440,7 @@
}
/**
- * Inner call to a BaseFunction
- * subclasses need to @Override this method.
+ * Inner call to a BaseFunction subclasses need to @Override this method.
*
* @param args an array of argument values sorted as per the signature.
* @param ast the source code for the function if user-defined
@@ -453,9 +448,8 @@
* @throws InterruptedException may be thrown in the function implementations.
*/
// Don't make it abstract, so that subclasses may be defined that @Override the outer call() only.
- protected Object call(Object[] args,
- @Nullable FuncallExpression ast, @Nullable Environment env)
- throws EvalException, ConversionException, InterruptedException {
+ protected Object call(Object[] args, @Nullable FuncallExpression ast, @Nullable Environment env)
+ throws EvalException, InterruptedException {
throw new EvalException(
(ast == null) ? Location.BUILTIN : ast.getLocation(),
String.format("function %s not implemented", getName()));
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/BinaryOperatorExpression.java b/src/main/java/com/google/devtools/build/lib/syntax/BinaryOperatorExpression.java
index 15989ec..b3067e2 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/BinaryOperatorExpression.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/BinaryOperatorExpression.java
@@ -268,6 +268,7 @@
/**
* Compile a comparison oer
+ *
* @param debugAccessors
* @param code
* @param leftCompiled
@@ -278,8 +279,7 @@
AstAccessors debugAccessors,
List<ByteCodeAppender> code,
ByteCodeAppender leftCompiled,
- ByteCodeAppender rightCompiled)
- throws Error {
+ ByteCodeAppender rightCompiled) {
PrimitiveComparison byteCodeOperator = PrimitiveComparison.forOperator(operator);
code.add(leftCompiled);
code.add(rightCompiled);
@@ -408,7 +408,7 @@
// Java: -7/3 = -2
// Python: -7/3 = -3
// We want to follow Python semantics, so we use float division and round down.
- return (int) Math.floor(new Double((Integer) lval) / (Integer) rval);
+ return (int) Math.floor(Double.valueOf((Integer) lval) / (Integer) rval);
}
throw typeException(lval, rval, Operator.DIVIDE, location);
}
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/BuiltinFunction.java b/src/main/java/com/google/devtools/build/lib/syntax/BuiltinFunction.java
index b3a763f..b050b2e 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/BuiltinFunction.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/BuiltinFunction.java
@@ -197,7 +197,7 @@
private static String stacktraceToString(StackTraceElement[] elts) {
StringBuilder b = new StringBuilder();
for (StackTraceElement e : elts) {
- b.append(e.toString());
+ b.append(e);
b.append("\n");
}
return b.toString();
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/Environment.java b/src/main/java/com/google/devtools/build/lib/syntax/Environment.java
index a1dd6ea..d03aa27 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/Environment.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/Environment.java
@@ -328,11 +328,11 @@
private boolean isSkylark;
/**
- * Is this Environment being executed during the loading phase?
- * Many builtin functions are only enabled during the loading phase, and check this flag.
+ * Is this Environment being executed during the loading phase? Many builtin functions are only
+ * enabled during the loading phase, and check this flag.
* TODO(laurentlb): Remove from Environment
*/
- private Phase phase;
+ private final Phase phase;
/**
* When in a lexical (Skylark) Frame, this set contains the variable names that are global,
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/FlowStatement.java b/src/main/java/com/google/devtools/build/lib/syntax/FlowStatement.java
index ac0eb9c..e498b9a 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/FlowStatement.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/FlowStatement.java
@@ -19,7 +19,6 @@
import com.google.devtools.build.lib.syntax.compiler.LoopLabels;
import com.google.devtools.build.lib.syntax.compiler.VariableScope;
import com.google.devtools.build.lib.util.Preconditions;
-
import net.bytebuddy.implementation.bytecode.ByteCodeAppender;
/**
@@ -30,7 +29,7 @@
BREAK("break"),
CONTINUE("continue");
- private String name;
+ private final String name;
private Kind(String name) {
this.name = name;
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/FormatParser.java b/src/main/java/com/google/devtools/build/lib/syntax/FormatParser.java
index b5ae740..64ad890 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/FormatParser.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/FormatParser.java
@@ -15,7 +15,6 @@
import com.google.common.collect.ImmutableSet;
import com.google.devtools.build.lib.events.Location;
-
import java.util.List;
import java.util.Map;
@@ -200,11 +199,10 @@
*
* @param key Key to be converted
* @param history Helper object that tracks information about previously seen positional
- * replacement fields
+ * replacement fields
* @return The integer equivalent of the key
*/
- protected int parsePositional(String key, History history)
- throws NumberFormatException, EvalException {
+ protected int parsePositional(String key, History history) throws EvalException {
int result = -1;
try {
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/FuncallExpression.java b/src/main/java/com/google/devtools/build/lib/syntax/FuncallExpression.java
index c476033..131d022 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/FuncallExpression.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/FuncallExpression.java
@@ -805,8 +805,7 @@
String name = arg.getName();
if (name != null && name.equals("name")) {
Expression expr = arg.getValue();
- return (expr != null && expr instanceof StringLiteral)
- ? ((StringLiteral) expr).getValue() : null;
+ return (expr instanceof StringLiteral) ? ((StringLiteral) expr).getValue() : null;
}
}
}
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/FunctionSignature.java b/src/main/java/com/google/devtools/build/lib/syntax/FunctionSignature.java
index b858d35..7643201 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/FunctionSignature.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/FunctionSignature.java
@@ -21,14 +21,13 @@
import com.google.devtools.build.lib.syntax.SkylarkList.Tuple;
import com.google.devtools.build.lib.util.Preconditions;
import com.google.devtools.build.lib.util.StringCanonicalizer;
-
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
+import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
-
import javax.annotation.Nullable;
/**
@@ -142,9 +141,7 @@
public List<Class<?>> toClasses() {
List<Class<?>> parameters = new ArrayList<>();
- for (int i = 0; i < getAllNamed(); i++) {
- parameters.add(Object.class);
- }
+ parameters.addAll(Collections.nCopies(getAllNamed(), Object.class));
if (hasStarArg()) {
parameters.add(Tuple.class);
}
@@ -156,10 +153,8 @@
}
}
- /**
- * Names of a FunctionSignature
- */
- private static Interner<ImmutableList<String>> namesInterner = Interners.newWeakInterner();
+ /** Names of a FunctionSignature */
+ private static final Interner<ImmutableList<String>> namesInterner = Interners.newWeakInterner();
/** Intern a list of names */
public static ImmutableList<String> names(List<String> names) {
@@ -173,7 +168,7 @@
}
// Interner
- private static Interner<FunctionSignature> signatureInterner = Interners.newWeakInterner();
+ private static final Interner<FunctionSignature> signatureInterner = Interners.newWeakInterner();
/**
* Signatures proper.
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/Lexer.java b/src/main/java/com/google/devtools/build/lib/syntax/Lexer.java
index d8b34be..71a3fd1 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/Lexer.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/Lexer.java
@@ -15,6 +15,7 @@
package com.google.devtools.build.lib.syntax;
import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.google.devtools.build.lib.concurrent.ThreadSafety.Immutable;
import com.google.devtools.build.lib.events.Event;
@@ -59,7 +60,7 @@
private final EventHandler eventHandler;
// Input buffer and position
- private char[] buffer;
+ private final char[] buffer;
private int pos;
/**
@@ -829,7 +830,7 @@
}
// Like Python, always end with a NEWLINE token, even if no '\n' in input:
- if (tokens.isEmpty() || tokens.get(tokens.size() - 1).kind != TokenKind.NEWLINE) {
+ if (tokens.isEmpty() || Iterables.getLast(tokens).kind != TokenKind.NEWLINE) {
addToken(new Token(TokenKind.NEWLINE, pos - 1, pos));
}
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/LineNumberTable.java b/src/main/java/com/google/devtools/build/lib/syntax/LineNumberTable.java
index 8789e68..d16a83d 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/LineNumberTable.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/LineNumberTable.java
@@ -21,13 +21,11 @@
import com.google.devtools.build.lib.util.Preconditions;
import com.google.devtools.build.lib.util.StringUtilities;
import com.google.devtools.build.lib.vfs.PathFragment;
-
import java.io.Serializable;
import java.nio.CharBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
-import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@@ -114,7 +112,8 @@
if (offset < 0) {
throw new IllegalStateException("Illegal position: " + offset);
}
- int lowBoundary = 1, highBoundary = linestart.length - 1;
+ int lowBoundary = 1;
+ int highBoundary = linestart.length - 1;
while (true) {
if ((highBoundary - lowBoundary) <= 1) {
if (linestart[highBoundary] > offset) {
@@ -194,13 +193,14 @@
}
}
- private static Ordering<SingleHashLine> hashOrdering = Ordering.from(
- new Comparator<SingleHashLine>() {
+ private static final Ordering<SingleHashLine> hashOrdering =
+ new Ordering<SingleHashLine>() {
+
@Override
public int compare(SingleHashLine o1, SingleHashLine o2) {
return Integer.compare(o1.offset, o2.offset);
}
- });
+ };
private static final Pattern pattern = Pattern.compile("\n#line ([0-9]+) \"([^\"\\n]+)\"");
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/MethodLibrary.java b/src/main/java/com/google/devtools/build/lib/syntax/MethodLibrary.java
index 21baa82..843d8e9 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/MethodLibrary.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/MethodLibrary.java
@@ -241,88 +241,126 @@
}
};
- @SkylarkSignature(name = "replace", objectType = StringModule.class, returnType = String.class,
- doc = "Returns a copy of the string in which the occurrences "
- + "of <code>old</code> have been replaced with <code>new</code>, optionally restricting "
- + "the number of replacements to <code>maxsplit</code>.",
- parameters = {
- @Param(name = "self", type = String.class, doc = "This string."),
- @Param(name = "old", type = String.class, doc = "The string to be replaced."),
- @Param(name = "new", type = String.class, doc = "The string to replace with."),
- @Param(name = "maxsplit", type = Integer.class, noneable = true, defaultValue = "None",
- doc = "The maximum number of replacements.")},
- useLocation = true)
- private static final BuiltinFunction replace = new BuiltinFunction("replace") {
- public String invoke(String self, String oldString, String newString, Object maxSplitO,
- Location loc) throws EvalException, ConversionException {
- StringBuffer sb = new StringBuffer();
- Integer maxSplit = Type.INTEGER.convertOptional(
- maxSplitO, "'maxsplit' argument of 'replace'", /*label*/null, Integer.MAX_VALUE);
- try {
- Matcher m = Pattern.compile(oldString, Pattern.LITERAL).matcher(self);
- for (int i = 0; i < maxSplit && m.find(); i++) {
- m.appendReplacement(sb, Matcher.quoteReplacement(newString));
+ @SkylarkSignature(
+ name = "replace",
+ objectType = StringModule.class,
+ returnType = String.class,
+ doc =
+ "Returns a copy of the string in which the occurrences "
+ + "of <code>old</code> have been replaced with <code>new</code>, optionally "
+ + "restricting the number of replacements to <code>maxsplit</code>.",
+ parameters = {
+ @Param(name = "self", type = String.class, doc = "This string."),
+ @Param(name = "old", type = String.class, doc = "The string to be replaced."),
+ @Param(name = "new", type = String.class, doc = "The string to replace with."),
+ @Param(
+ name = "maxsplit",
+ type = Integer.class,
+ noneable = true,
+ defaultValue = "None",
+ doc = "The maximum number of replacements."
+ )
+ },
+ useLocation = true
+ )
+ private static final BuiltinFunction replace =
+ new BuiltinFunction("replace") {
+ public String invoke(
+ String self, String oldString, String newString, Object maxSplitO, Location loc)
+ throws EvalException {
+ StringBuffer sb = new StringBuffer();
+ Integer maxSplit =
+ Type.INTEGER.convertOptional(
+ maxSplitO, "'maxsplit' argument of 'replace'", /*label*/ null, Integer.MAX_VALUE);
+ try {
+ Matcher m = Pattern.compile(oldString, Pattern.LITERAL).matcher(self);
+ for (int i = 0; i < maxSplit && m.find(); i++) {
+ m.appendReplacement(sb, Matcher.quoteReplacement(newString));
+ }
+ m.appendTail(sb);
+ } catch (IllegalStateException e) {
+ throw new EvalException(loc, e.getMessage() + " in call to replace");
+ }
+ return sb.toString();
}
- m.appendTail(sb);
- } catch (IllegalStateException e) {
- throw new EvalException(loc, e.getMessage() + " in call to replace");
- }
- return sb.toString();
- }
- };
+ };
- @SkylarkSignature(name = "split", objectType = StringModule.class,
- returnType = MutableList.class,
- doc = "Returns a list of all the words in the string, using <code>sep</code> "
- + "as the separator, optionally limiting the number of splits to <code>maxsplit</code>.",
- parameters = {
- @Param(name = "self", type = String.class, doc = "This string."),
- @Param(name = "sep", type = String.class, doc = "The string to split on."),
- @Param(name = "maxsplit", type = Integer.class, noneable = true, defaultValue = "None",
- doc = "The maximum number of splits.")},
- useEnvironment = true,
- useLocation = true)
- private static final BuiltinFunction split = new BuiltinFunction("split") {
- public MutableList<String> invoke(String self, String sep, Object maxSplitO, Location loc,
- Environment env) throws ConversionException, EvalException {
- int maxSplit = Type.INTEGER.convertOptional(
- maxSplitO, "'split' argument of 'split'", /*label*/null, -2);
- // + 1 because the last result is the remainder, and default of -2 so that after +1 it's -1
- String[] ss = Pattern.compile(sep, Pattern.LITERAL).split(self, maxSplit + 1);
- return MutableList.of(env, ss);
- }
- };
+ @SkylarkSignature(
+ name = "split",
+ objectType = StringModule.class,
+ returnType = MutableList.class,
+ doc =
+ "Returns a list of all the words in the string, using <code>sep</code> as the separator, "
+ + "optionally limiting the number of splits to <code>maxsplit</code>.",
+ parameters = {
+ @Param(name = "self", type = String.class, doc = "This string."),
+ @Param(name = "sep", type = String.class, doc = "The string to split on."),
+ @Param(
+ name = "maxsplit",
+ type = Integer.class,
+ noneable = true,
+ defaultValue = "None",
+ doc = "The maximum number of splits."
+ )
+ },
+ useEnvironment = true,
+ useLocation = true
+ )
+ private static final BuiltinFunction split =
+ new BuiltinFunction("split") {
+ public MutableList<String> invoke(
+ String self, String sep, Object maxSplitO, Location loc, Environment env)
+ throws EvalException {
+ int maxSplit =
+ Type.INTEGER.convertOptional(
+ maxSplitO, "'split' argument of 'split'", /*label*/ null, -2);
+ // + 1 because the last result is the remainder. The default is -2 so that after +1,
+ // it becomes -1.
+ String[] ss = Pattern.compile(sep, Pattern.LITERAL).split(self, maxSplit + 1);
+ return MutableList.of(env, ss);
+ }
+ };
- @SkylarkSignature(name = "rsplit", objectType = StringModule.class,
- returnType = MutableList.class,
- doc = "Returns a list of all the words in the string, using <code>sep</code> "
- + "as the separator, optionally limiting the number of splits to <code>maxsplit</code>. "
- + "Except for splitting from the right, this method behaves like split().",
- parameters = {
- @Param(name = "self", type = String.class, doc = "This string."),
- @Param(name = "sep", type = String.class, doc = "The string to split on."),
- @Param(name = "maxsplit", type = Integer.class, noneable = true,
- defaultValue = "None", doc = "The maximum number of splits.")},
- useEnvironment = true,
- useLocation = true)
- private static final BuiltinFunction rsplit = new BuiltinFunction("rsplit") {
- @SuppressWarnings("unused")
- public MutableList<String> invoke(
- String self, String sep, Object maxSplitO, Location loc, Environment env)
- throws ConversionException, EvalException {
- int maxSplit =
- Type.INTEGER.convertOptional(maxSplitO, "'split' argument of 'split'", null, -1);
- try {
- return stringRSplit(self, sep, maxSplit, env);
- } catch (IllegalArgumentException ex) {
- throw new EvalException(loc, ex);
- }
- }
- };
+ @SkylarkSignature(
+ name = "rsplit",
+ objectType = StringModule.class,
+ returnType = MutableList.class,
+ doc =
+ "Returns a list of all the words in the string, using <code>sep</code> as the separator, "
+ + "optionally limiting the number of splits to <code>maxsplit</code>. "
+ + "Except for splitting from the right, this method behaves like split().",
+ parameters = {
+ @Param(name = "self", type = String.class, doc = "This string."),
+ @Param(name = "sep", type = String.class, doc = "The string to split on."),
+ @Param(
+ name = "maxsplit",
+ type = Integer.class,
+ noneable = true,
+ defaultValue = "None",
+ doc = "The maximum number of splits."
+ )
+ },
+ useEnvironment = true,
+ useLocation = true
+ )
+ private static final BuiltinFunction rsplit =
+ new BuiltinFunction("rsplit") {
+ @SuppressWarnings("unused")
+ public MutableList<String> invoke(
+ String self, String sep, Object maxSplitO, Location loc, Environment env)
+ throws EvalException {
+ int maxSplit =
+ Type.INTEGER.convertOptional(maxSplitO, "'split' argument of 'split'", null, -1);
+ try {
+ return stringRSplit(self, sep, maxSplit, env);
+ } catch (IllegalArgumentException ex) {
+ throw new EvalException(loc, ex);
+ }
+ }
+ };
/**
- * Splits the given string into a list of words, using {@code separator} as a
- * delimiter.
+ * Splits the given string into a list of words, using {@code separator} as a delimiter.
*
* <p>At most {@code maxSplits} will be performed, going from right to left.
*
@@ -333,8 +371,7 @@
* @throws IllegalArgumentException
*/
private static MutableList<String> stringRSplit(
- String input, String separator, int maxSplits, Environment env)
- throws IllegalArgumentException {
+ String input, String separator, int maxSplits, Environment env) {
if (separator.isEmpty()) {
throw new IllegalArgumentException("Empty separator");
}
@@ -429,26 +466,23 @@
}
/**
- * Splits the input string at the {first|last} occurrence of the given separator
- * and returns the resulting partition as a three-tuple of Strings, contained
- * in a {@code MutableList}.
+ * Splits the input string at the {first|last} occurrence of the given separator and returns the
+ * resulting partition as a three-tuple of Strings, contained in a {@code MutableList}.
*
- * <p>If the input string does not contain the separator, the tuple will
- * consist of the original input string and two empty strings.
+ * <p>If the input string does not contain the separator, the tuple will consist of the original
+ * input string and two empty strings.
*
- * <p>This method emulates the behavior of Python's str.partition() and
- * str.rpartition(), depending on the value of the {@code forward} flag.
+ * <p>This method emulates the behavior of Python's str.partition() and str.rpartition(),
+ * depending on the value of the {@code forward} flag.
*
* @param input The input string
* @param separator The string to split on
- * @param forward A flag that controls whether the input string is split around
- * the first ({@code true}) or last ({@code false}) occurrence of the separator.
+ * @param forward A flag that controls whether the input string is split around the first ({@code
+ * true}) or last ({@code false}) occurrence of the separator.
* @return A three-tuple (List) of the form [part_before_separator, separator,
- * part_after_separator].
- *
+ * part_after_separator].
*/
- private static List<String> stringPartition(String input, String separator, boolean forward)
- throws IllegalArgumentException {
+ private static List<String> stringPartition(String input, String separator, boolean forward) {
if (separator.isEmpty()) {
throw new IllegalArgumentException("Empty separator");
}
@@ -584,53 +618,85 @@
}
};
- @SkylarkSignature(name = "rindex", objectType = StringModule.class, returnType = Integer.class,
- doc = "Returns the last index where <code>sub</code> is found, "
- + "or raises an error if no such index exists, optionally restricting to "
- + "[<code>start</code>:<code>end</code>], "
- + "<code>start</code> being inclusive and <code>end</code> being exclusive.",
- parameters = {
- @Param(name = "self", type = String.class, doc = "This string."),
- @Param(name = "sub", type = String.class, doc = "The substring to find."),
- @Param(name = "start", type = Integer.class, defaultValue = "0",
- doc = "Restrict to search from this position."),
- @Param(name = "end", type = Integer.class, noneable = true, defaultValue = "None",
- doc = "optional position before which to restrict to search.")},
- useLocation = true)
- private static final BuiltinFunction rindex = new BuiltinFunction("rindex") {
- public Integer invoke(String self, String sub, Integer start, Object end,
- Location loc) throws EvalException, ConversionException {
- int res = stringFind(false, self, sub, start, end, "'end' argument to rindex");
- if (res < 0) {
- throw new EvalException(loc, Printer.format("substring %r not found in %r", sub, self));
- }
- return res;
- }
- };
+ @SkylarkSignature(
+ name = "rindex",
+ objectType = StringModule.class,
+ returnType = Integer.class,
+ doc =
+ "Returns the last index where <code>sub</code> is found, "
+ + "or raises an error if no such index exists, optionally restricting to "
+ + "[<code>start</code>:<code>end</code>], "
+ + "<code>start</code> being inclusive and <code>end</code> being exclusive.",
+ parameters = {
+ @Param(name = "self", type = String.class, doc = "This string."),
+ @Param(name = "sub", type = String.class, doc = "The substring to find."),
+ @Param(
+ name = "start",
+ type = Integer.class,
+ defaultValue = "0",
+ doc = "Restrict to search from this position."
+ ),
+ @Param(
+ name = "end",
+ type = Integer.class,
+ noneable = true,
+ defaultValue = "None",
+ doc = "optional position before which to restrict to search."
+ )
+ },
+ useLocation = true
+ )
+ private static final BuiltinFunction rindex =
+ new BuiltinFunction("rindex") {
+ public Integer invoke(String self, String sub, Integer start, Object end, Location loc)
+ throws EvalException {
+ int res = stringFind(false, self, sub, start, end, "'end' argument to rindex");
+ if (res < 0) {
+ throw new EvalException(loc, Printer.format("substring %r not found in %r", sub, self));
+ }
+ return res;
+ }
+ };
- @SkylarkSignature(name = "index", objectType = StringModule.class, returnType = Integer.class,
- doc = "Returns the first index where <code>sub</code> is found, "
- + "or raises an error if no such index exists, optionally restricting to "
- + "[<code>start</code>:<code>end]</code>, "
- + "<code>start</code> being inclusive and <code>end</code> being exclusive.",
- parameters = {
- @Param(name = "self", type = String.class, doc = "This string."),
- @Param(name = "sub", type = String.class, doc = "The substring to find."),
- @Param(name = "start", type = Integer.class, defaultValue = "0",
- doc = "Restrict to search from this position."),
- @Param(name = "end", type = Integer.class, noneable = true, defaultValue = "None",
- doc = "optional position before which to restrict to search.")},
- useLocation = true)
- private static final BuiltinFunction index = new BuiltinFunction("index") {
- public Integer invoke(String self, String sub, Integer start, Object end,
- Location loc) throws EvalException, ConversionException {
- int res = stringFind(true, self, sub, start, end, "'end' argument to index");
- if (res < 0) {
- throw new EvalException(loc, Printer.format("substring %r not found in %r", sub, self));
- }
- return res;
- }
- };
+ @SkylarkSignature(
+ name = "index",
+ objectType = StringModule.class,
+ returnType = Integer.class,
+ doc =
+ "Returns the first index where <code>sub</code> is found, "
+ + "or raises an error if no such index exists, optionally restricting to "
+ + "[<code>start</code>:<code>end]</code>, "
+ + "<code>start</code> being inclusive and <code>end</code> being exclusive.",
+ parameters = {
+ @Param(name = "self", type = String.class, doc = "This string."),
+ @Param(name = "sub", type = String.class, doc = "The substring to find."),
+ @Param(
+ name = "start",
+ type = Integer.class,
+ defaultValue = "0",
+ doc = "Restrict to search from this position."
+ ),
+ @Param(
+ name = "end",
+ type = Integer.class,
+ noneable = true,
+ defaultValue = "None",
+ doc = "optional position before which to restrict to search."
+ )
+ },
+ useLocation = true
+ )
+ private static final BuiltinFunction index =
+ new BuiltinFunction("index") {
+ public Integer invoke(String self, String sub, Integer start, Object end, Location loc)
+ throws EvalException {
+ int res = stringFind(true, self, sub, start, end, "'end' argument to index");
+ if (res < 0) {
+ throw new EvalException(loc, Printer.format("substring %r not found in %r", sub, self));
+ }
+ return res;
+ }
+ };
@SkylarkSignature(name = "splitlines", objectType = StringModule.class,
returnType = SkylarkList.class,
@@ -857,39 +923,57 @@
// In Python, formatting is very complex.
// We handle here the simplest case which provides most of the value of the function.
// https://docs.python.org/3/library/string.html#formatstrings
- @SkylarkSignature(name = "format", objectType = StringModule.class, returnType = String.class,
- doc = "Perform string interpolation. Format strings contain replacement fields "
- + "surrounded by curly braces <code>{}</code>. Anything that is not contained "
- + "in braces is considered literal text, which is copied unchanged to the output."
- + "If you need to include a brace character in the literal text, it can be "
- + "escaped by doubling: <code>{{</code> and <code>}}</code>"
- + "A replacement field can be either a name, a number, or empty. Values are "
- + "converted to strings using the <a href=\"globals.html#str\">str</a> function."
- + "<pre class=\"language-python\">"
- + "# Access in order:\n"
- + "\"{} < {}\".format(4, 5) == \"4 < 5\"\n"
- + "# Access by position:\n"
- + "\"{1}, {0}\".format(2, 1) == \"1, 2\"\n"
- + "# Access by name:\n"
- + "\"x{key}x\".format(key = 2) == \"x2x\"</pre>\n",
- parameters = {
- @Param(name = "self", type = String.class, doc = "This string."),
- },
- extraPositionals =
- @Param(name = "args", type = SkylarkList.class, defaultValue = "()",
- doc = "List of arguments"),
- extraKeywords = @Param(name = "kwargs", type = SkylarkDict.class, defaultValue = "{}",
- doc = "Dictionary of arguments"),
- useLocation = true)
- private static final BuiltinFunction format = new BuiltinFunction("format") {
- @SuppressWarnings("unused")
- public String invoke(String self, SkylarkList<Object> args, SkylarkDict<?, ?> kwargs,
- Location loc)
- throws ConversionException, EvalException {
- return new FormatParser(loc).format(
- self, args.getImmutableList(), kwargs.getContents(String.class, Object.class, "kwargs"));
- }
- };
+ @SkylarkSignature(
+ name = "format",
+ objectType = StringModule.class,
+ returnType = String.class,
+ doc =
+ "Perform string interpolation. Format strings contain replacement fields "
+ + "surrounded by curly braces <code>{}</code>. Anything that is not contained "
+ + "in braces is considered literal text, which is copied unchanged to the output."
+ + "If you need to include a brace character in the literal text, it can be "
+ + "escaped by doubling: <code>{{</code> and <code>}}</code>"
+ + "A replacement field can be either a name, a number, or empty. Values are "
+ + "converted to strings using the <a href=\"globals.html#str\">str</a> function."
+ + "<pre class=\"language-python\">"
+ + "# Access in order:\n"
+ + "\"{} < {}\".format(4, 5) == \"4 < 5\"\n"
+ + "# Access by position:\n"
+ + "\"{1}, {0}\".format(2, 1) == \"1, 2\"\n"
+ + "# Access by name:\n"
+ + "\"x{key}x\".format(key = 2) == \"x2x\"</pre>\n",
+ parameters = {
+ @Param(name = "self", type = String.class, doc = "This string."),
+ },
+ extraPositionals =
+ @Param(
+ name = "args",
+ type = SkylarkList.class,
+ defaultValue = "()",
+ doc = "List of arguments"
+ ),
+ extraKeywords =
+ @Param(
+ name = "kwargs",
+ type = SkylarkDict.class,
+ defaultValue = "{}",
+ doc = "Dictionary of arguments"
+ ),
+ useLocation = true
+ )
+ private static final BuiltinFunction format =
+ new BuiltinFunction("format") {
+ @SuppressWarnings("unused")
+ public String invoke(
+ String self, SkylarkList<Object> args, SkylarkDict<?, ?> kwargs, Location loc)
+ throws EvalException {
+ return new FormatParser(loc)
+ .format(
+ self,
+ args.getImmutableList(),
+ kwargs.getContents(String.class, Object.class, "kwargs"));
+ }
+ };
@SkylarkSignature(name = "startswith", objectType = StringModule.class,
returnType = Boolean.class,
@@ -1087,11 +1171,10 @@
private static final BuiltinFunction sorted =
new BuiltinFunction("sorted") {
public <E> MutableList<E> invoke(Object self, Location loc, Environment env)
- throws EvalException, ConversionException {
+ throws EvalException {
try {
return new MutableList(
- EvalUtils.SKYLARK_COMPARATOR.sortedCopy(EvalUtils.toCollection(self, loc)),
- env);
+ EvalUtils.SKYLARK_COMPARATOR.sortedCopy(EvalUtils.toCollection(self, loc)), env);
} catch (EvalUtils.ComparisonException e) {
throw new EvalException(loc, e);
}
@@ -1142,11 +1225,13 @@
@Param(name = "item", type = Object.class, doc = "Item to add at the end.")
},
useLocation = true,
- useEnvironment = true)
+ useEnvironment = true
+ )
private static final BuiltinFunction append =
new BuiltinFunction("append") {
- public Runtime.NoneType invoke(MutableList<Object> self, Object item,
- Location loc, Environment env) throws EvalException, ConversionException {
+ public Runtime.NoneType invoke(
+ MutableList<Object> self, Object item, Location loc, Environment env)
+ throws EvalException {
self.add(item, loc, env);
return Runtime.NONE;
}
@@ -1169,7 +1254,7 @@
new BuiltinFunction("insert") {
public Runtime.NoneType invoke(
MutableList<Object> self, Integer index, Object item, Location loc, Environment env)
- throws EvalException, ConversionException {
+ throws EvalException {
self.add(clampIndex(index, self.size()), item, loc, env);
return Runtime.NONE;
}
@@ -1191,7 +1276,7 @@
new BuiltinFunction("extend") {
public Runtime.NoneType invoke(
MutableList<Object> self, SkylarkList<Object> items, Location loc, Environment env)
- throws EvalException, ConversionException {
+ throws EvalException {
self.addAll(items, loc, env);
return Runtime.NONE;
}
@@ -1441,39 +1526,46 @@
}
};
- @SkylarkSignature(name = "values", objectType = SkylarkDict.class,
- returnType = MutableList.class,
- doc = "Returns the list of values. Dictionaries are always sorted by their keys:"
- + "<pre class=\"language-python\">"
- + "{2: \"a\", 4: \"b\", 1: \"c\"}.values() == [\"c\", \"a\", \"b\"]</pre>\n",
- parameters = {@Param(name = "self", type = SkylarkDict.class, doc = "This dict.")},
- useEnvironment = true)
- private static final BuiltinFunction values = new BuiltinFunction("values") {
- public MutableList<?> invoke(SkylarkDict<?, ?> self,
- Environment env) throws EvalException, ConversionException {
- return new MutableList(self.values(), env);
- }
- };
+ @SkylarkSignature(
+ name = "values",
+ objectType = SkylarkDict.class,
+ returnType = MutableList.class,
+ doc =
+ "Returns the list of values. Dictionaries are always sorted by their keys:"
+ + "<pre class=\"language-python\">"
+ + "{2: \"a\", 4: \"b\", 1: \"c\"}.values() == [\"c\", \"a\", \"b\"]</pre>\n",
+ parameters = {@Param(name = "self", type = SkylarkDict.class, doc = "This dict.")},
+ useEnvironment = true
+ )
+ private static final BuiltinFunction values =
+ new BuiltinFunction("values") {
+ public MutableList<?> invoke(SkylarkDict<?, ?> self, Environment env) throws EvalException {
+ return new MutableList(self.values(), env);
+ }
+ };
- @SkylarkSignature(name = "items", objectType = SkylarkDict.class,
- returnType = MutableList.class,
- doc = "Returns the list of key-value tuples. Dictionaries are always sorted by their keys:"
- + "<pre class=\"language-python\">"
- + "{2: \"a\", 4: \"b\", 1: \"c\"}.items() == [(1, \"c\"), (2, \"a\"), (4, \"b\")]"
- + "</pre>\n",
- parameters = {
- @Param(name = "self", type = SkylarkDict.class, doc = "This dict.")},
- useEnvironment = true)
- private static final BuiltinFunction items = new BuiltinFunction("items") {
- public MutableList<?> invoke(SkylarkDict<?, ?> self,
- Environment env) throws EvalException, ConversionException {
- List<Object> list = Lists.newArrayListWithCapacity(self.size());
- for (Map.Entry<?, ?> entries : self.entrySet()) {
- list.add(Tuple.of(entries.getKey(), entries.getValue()));
- }
- return new MutableList(list, env);
- }
- };
+ @SkylarkSignature(
+ name = "items",
+ objectType = SkylarkDict.class,
+ returnType = MutableList.class,
+ doc =
+ "Returns the list of key-value tuples. Dictionaries are always sorted by their keys:"
+ + "<pre class=\"language-python\">"
+ + "{2: \"a\", 4: \"b\", 1: \"c\"}.items() == [(1, \"c\"), (2, \"a\"), (4, \"b\")]"
+ + "</pre>\n",
+ parameters = {@Param(name = "self", type = SkylarkDict.class, doc = "This dict.")},
+ useEnvironment = true
+ )
+ private static final BuiltinFunction items =
+ new BuiltinFunction("items") {
+ public MutableList<?> invoke(SkylarkDict<?, ?> self, Environment env) throws EvalException {
+ List<Object> list = Lists.newArrayListWithCapacity(self.size());
+ for (Map.Entry<?, ?> entries : self.entrySet()) {
+ list.add(Tuple.of(entries.getKey(), entries.getValue()));
+ }
+ return new MutableList(list, env);
+ }
+ };
@SkylarkSignature(name = "keys", objectType = SkylarkDict.class,
returnType = MutableList.class,
@@ -1680,33 +1772,47 @@
};
@SkylarkSignature(
- name = "set",
- returnType = SkylarkNestedSet.class,
- doc = "Creates a <a href=\"set.html\">set</a> from the <code>items</code>. "
- + "The set supports nesting other sets of the same element type in it. "
- + "A desired <a href=\"set.html\">iteration order</a> can also be specified.<br>"
- + "Examples:<br><pre class=\"language-python\">set([\"a\", \"b\"])\n"
- + "set([1, 2, 3], order=\"compile\")</pre>",
- parameters = {
- @Param(name = "items", type = Object.class, defaultValue = "[]",
- doc = "The items to initialize the set with. May contain both standalone items "
- + "and other sets."),
- @Param(name = "order", type = String.class, defaultValue = "\"stable\"",
- doc = "The ordering strategy for the set if it's nested, "
- + "possible values are: <code>stable</code> (default), <code>compile</code>, "
- + "<code>link</code> or <code>naive_link</code>. An explanation of the "
- + "values can be found <a href=\"set.html\">here</a>.")},
- useLocation = true)
- private static final BuiltinFunction set = new BuiltinFunction("set") {
- public SkylarkNestedSet invoke(Object items, String order,
- Location loc) throws EvalException, ConversionException {
- try {
- return new SkylarkNestedSet(Order.parse(order), items, loc);
- } catch (IllegalArgumentException ex) {
- throw new EvalException(loc, ex);
- }
- }
- };
+ name = "set",
+ returnType = SkylarkNestedSet.class,
+ doc =
+ "Creates a <a href=\"set.html\">set</a> from the <code>items</code>. "
+ + "The set supports nesting other sets of the same element type in it. "
+ + "A desired <a href=\"set.html\">iteration order</a> can also be specified.<br>"
+ + "Examples:<br><pre class=\"language-python\">set([\"a\", \"b\"])\n"
+ + "set([1, 2, 3], order=\"compile\")</pre>",
+ parameters = {
+ @Param(
+ name = "items",
+ type = Object.class,
+ defaultValue = "[]",
+ doc =
+ "The items to initialize the set with. May contain both standalone items "
+ + "and other sets."
+ ),
+ @Param(
+ name = "order",
+ type = String.class,
+ defaultValue = "\"stable\"",
+ doc =
+ "The ordering strategy for the set if it's nested, "
+ + "possible values are: <code>stable</code> (default), <code>compile</code>, "
+ + "<code>link</code> or <code>naive_link</code>. An explanation of the "
+ + "values can be found <a href=\"set.html\">here</a>."
+ )
+ },
+ useLocation = true
+ )
+ private static final BuiltinFunction set =
+ new BuiltinFunction("set") {
+ public SkylarkNestedSet invoke(Object items, String order, Location loc)
+ throws EvalException {
+ try {
+ return new SkylarkNestedSet(Order.parse(order), items, loc);
+ } catch (IllegalArgumentException ex) {
+ throw new EvalException(loc, ex);
+ }
+ }
+ };
@SkylarkSignature(
name = "dict",
@@ -1791,26 +1897,28 @@
}
};
- @SkylarkSignature(name = "enumerate", returnType = MutableList.class,
- doc = "Returns a list of pairs (two-element tuples), with the index (int) and the item from"
- + " the input list.\n<pre class=\"language-python\">"
- + "enumerate([24, 21, 84]) == [(0, 24), (1, 21), (2, 84)]</pre>\n",
- parameters = {
- @Param(name = "list", type = SkylarkList.class, doc = "input list")
- },
- useEnvironment = true)
- private static final BuiltinFunction enumerate = new BuiltinFunction("enumerate") {
- public MutableList<?> invoke(SkylarkList<?> input, Environment env)
- throws EvalException, ConversionException {
- int count = 0;
- List<SkylarkList<?>> result = Lists.newArrayList();
- for (Object obj : input) {
- result.add(Tuple.of(count, obj));
- count++;
- }
- return new MutableList(result, env);
- }
- };
+ @SkylarkSignature(
+ name = "enumerate",
+ returnType = MutableList.class,
+ doc =
+ "Returns a list of pairs (two-element tuples), with the index (int) and the item from"
+ + " the input list.\n<pre class=\"language-python\">"
+ + "enumerate([24, 21, 84]) == [(0, 24), (1, 21), (2, 84)]</pre>\n",
+ parameters = {@Param(name = "list", type = SkylarkList.class, doc = "input list")},
+ useEnvironment = true
+ )
+ private static final BuiltinFunction enumerate =
+ new BuiltinFunction("enumerate") {
+ public MutableList<?> invoke(SkylarkList<?> input, Environment env) throws EvalException {
+ int count = 0;
+ List<SkylarkList<?>> result = Lists.newArrayList();
+ for (Object obj : input) {
+ result.add(Tuple.of(count, obj));
+ count++;
+ }
+ return new MutableList(result, env);
+ }
+ };
@SkylarkSignature(name = "hash", returnType = Integer.class,
doc = "Return a hash value for a string. This is computed deterministically using the same "
@@ -1830,59 +1938,79 @@
}
};
- @SkylarkSignature(name = "range", returnType = MutableList.class,
- doc = "Creates a list where items go from <code>start</code> to <code>stop</code>, using a "
- + "<code>step</code> increment. If a single argument is provided, items will "
- + "range from 0 to that element."
- + "<pre class=\"language-python\">range(4) == [0, 1, 2, 3]\n"
- + "range(3, 9, 2) == [3, 5, 7]\n"
- + "range(3, 0, -1) == [3, 2, 1]</pre>",
- parameters = {
- @Param(name = "start_or_stop", type = Integer.class,
- doc = "Value of the start element if stop is provided, "
- + "otherwise value of stop and the actual start is 0"),
- @Param(name = "stop_or_none", type = Integer.class, noneable = true, defaultValue = "None",
- doc = "optional index of the first item <i>not</i> to be included in the "
- + "resulting list; generation of the list stops before <code>stop</code> is reached."),
- @Param(name = "step", type = Integer.class, defaultValue = "1",
- doc = "The increment (default is 1). It may be negative.")},
- useLocation = true,
- useEnvironment = true)
- private static final BuiltinFunction range = new BuiltinFunction("range") {
- public MutableList<?> invoke(Integer startOrStop, Object stopOrNone, Integer step,
- Location loc, Environment env)
- throws EvalException, ConversionException {
- int start;
- int stop;
- if (stopOrNone == Runtime.NONE) {
- start = 0;
- stop = startOrStop;
- } else {
- start = startOrStop;
- stop = Type.INTEGER.convert(stopOrNone, "'stop' operand of 'range'");
- }
- if (step == 0) {
- throw new EvalException(loc, "step cannot be 0");
- }
- ArrayList<Integer> result = Lists.newArrayList();
- if (step > 0) {
- int size = (stop - start) / step;
- result.ensureCapacity(size);
- while (start < stop) {
- result.add(start);
- start += step;
+ @SkylarkSignature(
+ name = "range",
+ returnType = MutableList.class,
+ doc =
+ "Creates a list where items go from <code>start</code> to <code>stop</code>, using a "
+ + "<code>step</code> increment. If a single argument is provided, items will "
+ + "range from 0 to that element."
+ + "<pre class=\"language-python\">range(4) == [0, 1, 2, 3]\n"
+ + "range(3, 9, 2) == [3, 5, 7]\n"
+ + "range(3, 0, -1) == [3, 2, 1]</pre>",
+ parameters = {
+ @Param(
+ name = "start_or_stop",
+ type = Integer.class,
+ doc =
+ "Value of the start element if stop is provided, "
+ + "otherwise value of stop and the actual start is 0"
+ ),
+ @Param(
+ name = "stop_or_none",
+ type = Integer.class,
+ noneable = true,
+ defaultValue = "None",
+ doc =
+ "optional index of the first item <i>not</i> to be included in the resulting "
+ + "list; generation of the list stops before <code>stop</code> is reached."
+ ),
+ @Param(
+ name = "step",
+ type = Integer.class,
+ defaultValue = "1",
+ doc = "The increment (default is 1). It may be negative."
+ )
+ },
+ useLocation = true,
+ useEnvironment = true
+ )
+ private static final BuiltinFunction range =
+ new BuiltinFunction("range") {
+ public MutableList<?> invoke(
+ Integer startOrStop, Object stopOrNone, Integer step, Location loc, Environment env)
+ throws EvalException {
+ int start;
+ int stop;
+ if (stopOrNone == Runtime.NONE) {
+ start = 0;
+ stop = startOrStop;
+ } else {
+ start = startOrStop;
+ stop = Type.INTEGER.convert(stopOrNone, "'stop' operand of 'range'");
+ }
+ if (step == 0) {
+ throw new EvalException(loc, "step cannot be 0");
+ }
+ ArrayList<Integer> result = Lists.newArrayList();
+ if (step > 0) {
+ int size = (stop - start) / step;
+ result.ensureCapacity(size);
+ while (start < stop) {
+ result.add(start);
+ start += step;
+ }
+ } else {
+ int size = (start - stop) / step;
+ result.ensureCapacity(size);
+ while (start > stop) {
+ result.add(start);
+ start += step;
+ }
+ }
+ return new MutableList(result, env);
}
- } else {
- int size = (start - stop) / step;
- result.ensureCapacity(size);
- while (start > stop) {
- result.add(start);
- start += step;
- }
- }
- return new MutableList(result, env);
- }
- };
+ };
/**
* Returns a function-value implementing "select" (i.e. configurable attributes)
@@ -1901,62 +2029,82 @@
}
};
- /**
- * Returns true if the object has a field of the given name, otherwise false.
- */
- @SkylarkSignature(name = "hasattr", returnType = Boolean.class,
- doc = "Returns True if the object <code>x</code> has an attribute or method of the given "
- + "<code>name</code>, otherwise False. Example:<br>"
- + "<pre class=\"language-python\">hasattr(ctx.attr, \"myattr\")</pre>",
- parameters = {
- @Param(name = "x", doc = "The object to check."),
- @Param(name = "name", type = String.class, doc = "The name of the attribute.")},
- useLocation = true, useEnvironment = true)
- private static final BuiltinFunction hasattr = new BuiltinFunction("hasattr") {
- @SuppressWarnings("unused")
- public Boolean invoke(Object obj, String name,
- Location loc, Environment env) throws EvalException, ConversionException {
- if (obj instanceof ClassObject && ((ClassObject) obj).getValue(name) != null) {
- return true;
- }
- return hasMethod(obj, name, loc);
- }
- };
-
- @SkylarkSignature(name = "getattr",
- doc = "Returns the struct's field of the given name if it exists. If not, it either returns "
- + "<code>default</code> (if specified) or raises an error. However, if there is a method "
- + "of the given name, this method always raises an error, regardless of the "
- + "presence of a default value. <code>getattr(x, \"foobar\")</code> is equivalent to "
- + "<code>x.foobar</code>."
- + "<pre class=\"language-python\">getattr(ctx.attr, \"myattr\")\n"
- + "getattr(ctx.attr, \"myattr\", \"mydefault\")</pre>",
- parameters = {
- @Param(name = "x", doc = "The struct whose attribute is accessed."),
- @Param(name = "name", doc = "The name of the struct attribute."),
- @Param(name = "default", defaultValue = "unbound",
- doc = "The default value to return in case the struct "
- + "doesn't have an attribute of the given name.")},
- useLocation = true, useEnvironment = true)
- private static final BuiltinFunction getattr = new BuiltinFunction("getattr") {
- @SuppressWarnings("unused")
- public Object invoke(Object obj, String name, Object defaultValue,
- Location loc, Environment env) throws EvalException, ConversionException {
- Object result = DotExpression.eval(obj, name, loc, env);
- if (result == null) {
- // 'Real' describes methods with structField() == false. Because DotExpression.eval returned
- // null in this case, we know that structField() cannot return true.
- boolean isRealMethod = hasMethod(obj, name, loc);
- if (defaultValue != Runtime.UNBOUND && !isRealMethod) {
- return defaultValue;
+ /** Returns true if the object has a field of the given name, otherwise false. */
+ @SkylarkSignature(
+ name = "hasattr",
+ returnType = Boolean.class,
+ doc =
+ "Returns True if the object <code>x</code> has an attribute or method of the given "
+ + "<code>name</code>, otherwise False. Example:<br>"
+ + "<pre class=\"language-python\">hasattr(ctx.attr, \"myattr\")</pre>",
+ parameters = {
+ @Param(name = "x", doc = "The object to check."),
+ @Param(name = "name", type = String.class, doc = "The name of the attribute.")
+ },
+ useLocation = true,
+ useEnvironment = true
+ )
+ private static final BuiltinFunction hasattr =
+ new BuiltinFunction("hasattr") {
+ @SuppressWarnings("unused")
+ public Boolean invoke(Object obj, String name, Location loc, Environment env)
+ throws EvalException {
+ if (obj instanceof ClassObject && ((ClassObject) obj).getValue(name) != null) {
+ return true;
+ }
+ return hasMethod(obj, name, loc);
}
- throw new EvalException(loc, Printer.format("Object of type '%s' has no attribute %r%s",
- EvalUtils.getDataTypeName(obj), name,
- isRealMethod ? ", however, a method of that name exists" : ""));
- }
- return result;
- }
- };
+ };
+
+ @SkylarkSignature(
+ name = "getattr",
+ doc =
+ "Returns the struct's field of the given name if it exists. If not, it either returns "
+ + "<code>default</code> (if specified) or raises an error. However, if there is a "
+ + "method of the given name, this method always raises an error, regardless of the "
+ + "presence of a default value. <code>getattr(x, \"foobar\")</code> is equivalent to "
+ + "<code>x.foobar</code>."
+ + "<pre class=\"language-python\">getattr(ctx.attr, \"myattr\")\n"
+ + "getattr(ctx.attr, \"myattr\", \"mydefault\")</pre>",
+ parameters = {
+ @Param(name = "x", doc = "The struct whose attribute is accessed."),
+ @Param(name = "name", doc = "The name of the struct attribute."),
+ @Param(
+ name = "default",
+ defaultValue = "unbound",
+ doc =
+ "The default value to return in case the struct "
+ + "doesn't have an attribute of the given name."
+ )
+ },
+ useLocation = true,
+ useEnvironment = true
+ )
+ private static final BuiltinFunction getattr =
+ new BuiltinFunction("getattr") {
+ @SuppressWarnings("unused")
+ public Object invoke(
+ Object obj, String name, Object defaultValue, Location loc, Environment env)
+ throws EvalException {
+ Object result = DotExpression.eval(obj, name, loc, env);
+ if (result == null) {
+ // 'Real' describes methods with structField() == false. Because DotExpression.eval
+ // returned null in this case, we know that structField() cannot return true.
+ boolean isRealMethod = hasMethod(obj, name, loc);
+ if (defaultValue != Runtime.UNBOUND && !isRealMethod) {
+ return defaultValue;
+ }
+ throw new EvalException(
+ loc,
+ Printer.format(
+ "Object of type '%s' has no attribute %r%s",
+ EvalUtils.getDataTypeName(obj),
+ name,
+ isRealMethod ? ", however, a method of that name exists" : ""));
+ }
+ return result;
+ }
+ };
/**
* Returns whether the given object has a method with the given name.
@@ -1974,29 +2122,35 @@
}
}
- @SkylarkSignature(name = "dir", returnType = MutableList.class,
- doc = "Returns a list strings: the names of the attributes and "
- + "methods of the parameter object.",
- parameters = {@Param(name = "x", doc = "The object to check.")},
- useLocation = true, useEnvironment = true)
- private static final BuiltinFunction dir = new BuiltinFunction("dir") {
- public MutableList<?> invoke(Object object,
- Location loc, Environment env) throws EvalException, ConversionException {
- // Order the fields alphabetically.
- Set<String> fields = new TreeSet<>();
- if (object instanceof ClassObject) {
- fields.addAll(((ClassObject) object).getKeys());
- }
- fields.addAll(Runtime.getFunctionNames(object.getClass()));
- try {
- fields.addAll(FuncallExpression.getMethodNames(object.getClass()));
- } catch (ExecutionException e) {
- // This shouldn't happen
- throw new EvalException(loc, e.getMessage());
- }
- return new MutableList(fields, env);
- }
- };
+ @SkylarkSignature(
+ name = "dir",
+ returnType = MutableList.class,
+ doc =
+ "Returns a list strings: the names of the attributes and "
+ + "methods of the parameter object.",
+ parameters = {@Param(name = "x", doc = "The object to check.")},
+ useLocation = true,
+ useEnvironment = true
+ )
+ private static final BuiltinFunction dir =
+ new BuiltinFunction("dir") {
+ public MutableList<?> invoke(Object object, Location loc, Environment env)
+ throws EvalException {
+ // Order the fields alphabetically.
+ Set<String> fields = new TreeSet<>();
+ if (object instanceof ClassObject) {
+ fields.addAll(((ClassObject) object).getKeys());
+ }
+ fields.addAll(Runtime.getFunctionNames(object.getClass()));
+ try {
+ fields.addAll(FuncallExpression.getMethodNames(object.getClass()));
+ } catch (ExecutionException e) {
+ // This shouldn't happen
+ throw new EvalException(loc, e.getMessage());
+ }
+ return new MutableList(fields, env);
+ }
+ };
@SkylarkSignature(
name = "type",
@@ -2050,8 +2204,7 @@
)
private static final BuiltinFunction fail =
new BuiltinFunction("fail") {
- public Runtime.NoneType invoke(Object msg, Object attr, Location loc)
- throws EvalException, ConversionException {
+ public Runtime.NoneType invoke(Object msg, Object attr, Location loc) throws EvalException {
String str = Printer.str(msg);
if (attr != Runtime.NONE) {
str = String.format("attribute %s: %s", attr, str);
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/Parameter.java b/src/main/java/com/google/devtools/build/lib/syntax/Parameter.java
index f0044c2..52bf299 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/Parameter.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/Parameter.java
@@ -47,9 +47,11 @@
public boolean isOptional() {
return false;
}
+ @Override
public boolean isStar() {
return false;
}
+ @Override
public boolean isStarStar() {
return false;
}
@@ -83,7 +85,7 @@
@Override
public String toString() {
- return name.toString();
+ return name;
}
}
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/Parser.java b/src/main/java/com/google/devtools/build/lib/syntax/Parser.java
index 18c2dbf..4d285a3 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/Parser.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/Parser.java
@@ -21,6 +21,7 @@
import com.google.common.base.Supplier;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
import com.google.devtools.build.lib.events.Event;
import com.google.devtools.build.lib.events.EventHandler;
import com.google.devtools.build.lib.events.Location;
@@ -185,7 +186,7 @@
EnumSet.of(Operator.MINUS, Operator.PLUS),
EnumSet.of(Operator.DIVIDE, Operator.MULT, Operator.PERCENT));
- private Iterator<Token> tokens = null;
+ private final Iterator<Token> tokens;
private int errorsCount;
private boolean recoveryMode; // stop reporting errors until next statement
@@ -202,7 +203,7 @@
if (!statements.isEmpty()) {
return lexer.createLocation(
statements.get(0).getLocation().getStartOffset(),
- statements.get(statements.size() - 1).getLocation().getEndOffset());
+ Iterables.getLast(statements).getLocation().getEndOffset());
} else {
return Location.fromPathFragment(lexer.getFilename());
}
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/Printer.java b/src/main/java/com/google/devtools/build/lib/syntax/Printer.java
index 88abe13..af6515f 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/Printer.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/Printer.java
@@ -20,11 +20,9 @@
import com.google.devtools.build.lib.skylarkinterface.SkylarkValue;
import com.google.devtools.build.lib.syntax.SkylarkList.Tuple;
import com.google.devtools.build.lib.vfs.PathFragment;
-
import java.io.IOException;
import java.util.Formattable;
import java.util.Formatter;
-import java.util.IllegalFormatException;
import java.util.List;
import java.util.Map;
import java.util.MissingFormatWidthException;
@@ -443,8 +441,7 @@
* @param arguments positional arguments.
* @return the formatted string.
*/
- public static Formattable formattable(final String pattern, Object... arguments)
- throws IllegalFormatException {
+ public static Formattable formattable(final String pattern, Object... arguments) {
final ImmutableList<Object> args = ImmutableList.copyOf(arguments);
return new Formattable() {
@Override
@@ -466,8 +463,7 @@
* @param arguments a tuple containing positional arguments.
* @return the formatted string.
*/
- public static String format(String pattern, Object... arguments)
- throws IllegalFormatException {
+ public static String format(String pattern, Object... arguments) {
return formatToString(pattern, ImmutableList.copyOf(arguments));
}
@@ -478,8 +474,7 @@
* @param arguments a tuple containing positional arguments.
* @return the formatted string.
*/
- public static String formatToString(String pattern, List<?> arguments)
- throws IllegalFormatException {
+ public static String formatToString(String pattern, List<?> arguments) {
return formatTo(new StringBuilder(), pattern, arguments).toString();
}
@@ -493,8 +488,7 @@
* @return the buffer, in fluent style.
*/
// TODO(bazel-team): support formatting arguments, and more complex Python patterns.
- public static Appendable formatTo(Appendable buffer, String pattern, List<?> arguments)
- throws IllegalFormatException {
+ public static Appendable formatTo(Appendable buffer, String pattern, List<?> arguments) {
// N.B. MissingFormatWidthException is the only kind of IllegalFormatException
// whose constructor can take and display arbitrary error message, hence its use below.
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/Runtime.java b/src/main/java/com/google/devtools/build/lib/syntax/Runtime.java
index 2795da1..f0608e6 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/Runtime.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/Runtime.java
@@ -21,13 +21,11 @@
import com.google.devtools.build.lib.skylarkinterface.SkylarkValue;
import com.google.devtools.build.lib.syntax.compiler.ByteCodeUtils;
import com.google.devtools.build.lib.util.Preconditions;
-
-import net.bytebuddy.implementation.bytecode.StackManipulation;
-
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
+import net.bytebuddy.implementation.bytecode.StackManipulation;
/**
* Global constants and support for global namespaces of runtime functions.
@@ -182,7 +180,8 @@
try {
if (moduleClass.isAnnotationPresent(SkylarkModule.class)) {
env.setup(
- moduleClass.getAnnotation(SkylarkModule.class).name(), moduleClass.newInstance());
+ moduleClass.getAnnotation(SkylarkModule.class).name(),
+ moduleClass.getConstructor().newInstance());
}
for (Field field : moduleClass.getDeclaredFields()) {
if (field.isAnnotationPresent(SkylarkSignature.class)) {
@@ -199,7 +198,7 @@
}
}
}
- } catch (IllegalAccessException | InstantiationException e) {
+ } catch (ReflectiveOperationException e) {
throw new AssertionError(e);
}
}
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/SkylarkDict.java b/src/main/java/com/google/devtools/build/lib/syntax/SkylarkDict.java
index fc5e9cf..6ae2ae5 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/SkylarkDict.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/SkylarkDict.java
@@ -46,9 +46,9 @@
public final class SkylarkDict<K, V>
extends MutableMap<K, V> implements Map<K, V>, SkylarkIndexable {
- private TreeMap<K, V> contents = new TreeMap<>(EvalUtils.SKYLARK_COMPARATOR);
+ private final TreeMap<K, V> contents = new TreeMap<>(EvalUtils.SKYLARK_COMPARATOR);
- private Mutability mutability;
+ private final Mutability mutability;
@Override
public Mutability mutability() {
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/SkylarkImports.java b/src/main/java/com/google/devtools/build/lib/syntax/SkylarkImports.java
index 99b604e..2910beb 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/SkylarkImports.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/SkylarkImports.java
@@ -56,7 +56,7 @@
}
private static final class AbsolutePathImport extends SkylarkImportImpl {
- private PathFragment importPath;
+ private final PathFragment importPath;
private AbsolutePathImport(String importString, PathFragment importPath) {
this.importString = importString;
@@ -85,7 +85,7 @@
}
private static final class RelativePathImport extends SkylarkImportImpl {
- private String importFile;
+ private final String importFile;
private RelativePathImport(String importString, String importFile) {
this.importString = importString;
@@ -116,7 +116,7 @@
}
private static final class AbsoluteLabelImport extends SkylarkImportImpl {
- private Label importLabel;
+ private final Label importLabel;
private AbsoluteLabelImport(String importString, Label importLabel) {
this.importString = importString;
@@ -137,7 +137,7 @@
}
private static final class RelativeLabelImport extends SkylarkImportImpl {
- private String importTarget;
+ private final String importTarget;
private RelativeLabelImport(String importString, String importTarget) {
this.importString = importString;
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/SkylarkSignatureProcessor.java b/src/main/java/com/google/devtools/build/lib/syntax/SkylarkSignatureProcessor.java
index 928165d..228ef85 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/SkylarkSignatureProcessor.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/SkylarkSignatureProcessor.java
@@ -13,6 +13,7 @@
// limitations under the License.
package com.google.devtools.build.lib.syntax;
+import com.google.common.primitives.Booleans;
import com.google.devtools.build.lib.skylarkinterface.Param;
import com.google.devtools.build.lib.skylarkinterface.SkylarkSignature;
import com.google.devtools.build.lib.syntax.BuiltinFunction.ExtraArgKind;
@@ -191,8 +192,9 @@
/** Extract additional signature information for BuiltinFunction-s */
public static ExtraArgKind[] getExtraArgs(SkylarkSignature annotation) {
- final int numExtraArgs = (annotation.useLocation() ? 1 : 0)
- + (annotation.useAst() ? 1 : 0) + (annotation.useEnvironment() ? 1 : 0);
+ final int numExtraArgs =
+ Booleans.countTrue(
+ annotation.useLocation(), annotation.useAst(), annotation.useEnvironment());
if (numExtraArgs == 0) {
return null;
}
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/SkylarkType.java b/src/main/java/com/google/devtools/build/lib/syntax/SkylarkType.java
index e73672a..d6695cb 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/SkylarkType.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/SkylarkType.java
@@ -139,7 +139,7 @@
return TOP;
}
- private final class Empty { }; // Empty type, used as basis for Bottom
+ private static final class Empty {}; // Empty type, used as basis for Bottom
// Notable types
@@ -256,13 +256,15 @@
return this.type == type || super.canBeCastTo(type);
}
- private static LoadingCache<Class<?>, Simple> simpleCache = CacheBuilder.newBuilder()
- .build(new CacheLoader<Class<?>, Simple>() {
- @Override
- public Simple load(Class<?> type) {
- return create(type);
- }
- });
+ private static final LoadingCache<Class<?>, Simple> simpleCache =
+ CacheBuilder.newBuilder()
+ .build(
+ new CacheLoader<Class<?>, Simple>() {
+ @Override
+ public Simple load(Class<?> type) {
+ return create(type);
+ }
+ });
private static Simple create(Class<?> type) {
Simple simple;
@@ -374,7 +376,7 @@
return genericType + " of " + argType + "s";
}
- private static Interner<Combination> combinationInterner =
+ private static final Interner<Combination> combinationInterner =
Interners.<Combination>newWeakInterner();
public static SkylarkType of(SkylarkType generic, SkylarkType argument) {
@@ -520,7 +522,7 @@
*/
public static final class SkylarkFunctionType extends SkylarkType {
private final String name;
- @Nullable private SkylarkType returnType;
+ @Nullable private final SkylarkType returnType;
@Override public SkylarkType intersectWith(SkylarkType other) {
// This gives the wrong result if both return types are incompatibly updated later!
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/UserDefinedFunction.java b/src/main/java/com/google/devtools/build/lib/syntax/UserDefinedFunction.java
index 60b293b..af36cd9 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/UserDefinedFunction.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/UserDefinedFunction.java
@@ -69,7 +69,7 @@
// we close over the globals at the time of definition
private final Environment.Frame definitionGlobals;
- private Optional<Method> method;
+ private final Optional<Method> method;
// TODO(bazel-team) make this configurable once the compiler is stable
public static boolean debugCompiler = false;
public static boolean debugCompilerPrintByteCode = false;
@@ -250,10 +250,7 @@
.getLoaded();
return Optional.of(
- ReflectionUtils.getMethod(
- functionClass,
- "call",
- parameterTypes.toArray(new Class<?>[parameterTypes.size()]))
+ ReflectionUtils.getMethod(functionClass, "call", parameterTypes.toArray(new Class<?>[0]))
.getLoadedMethod());
} catch (EvalException e) {
// don't capture EvalExceptions
@@ -295,8 +292,7 @@
}
// add a return None if there are no statements or the last one to ensure the method always
// returns something. This implements the interpreters behavior.
- if (statements.isEmpty()
- || !(statements.get(statements.size() - 1) instanceof ReturnStatement)) {
+ if (statements.isEmpty() || !(Iterables.getLast(statements) instanceof ReturnStatement)) {
code.add(new ByteCodeAppender.Simple(Runtime.GET_NONE, MethodReturn.REFERENCE));
}
// we now know which variables we used in the method, so assign them "undefined" (i.e. null)
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/ValidationEnvironment.java b/src/main/java/com/google/devtools/build/lib/syntax/ValidationEnvironment.java
index 991b106..095b46f 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/ValidationEnvironment.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/ValidationEnvironment.java
@@ -18,7 +18,6 @@
import com.google.devtools.build.lib.events.EventHandler;
import com.google.devtools.build.lib.events.Location;
import com.google.devtools.build.lib.util.Preconditions;
-
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
@@ -36,15 +35,15 @@
private final ValidationEnvironment parent;
- private Set<String> variables = new HashSet<>();
+ private final Set<String> variables = new HashSet<>();
- private Map<String, Location> variableLocations = new HashMap<>();
+ private final Map<String, Location> variableLocations = new HashMap<>();
- private Set<String> readOnlyVariables = new HashSet<>();
+ private final Set<String> readOnlyVariables = new HashSet<>();
// A stack of variable-sets which are read only but can be assigned in different
// branches of if-else statements.
- private Stack<Set<String>> futureReadOnlyVariables = new Stack<>();
+ private final Stack<Set<String>> futureReadOnlyVariables = new Stack<>();
/**
* Tracks the number of nested for loops that contain the statement that is currently being
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/compiler/ByteCodeUtils.java b/src/main/java/com/google/devtools/build/lib/syntax/compiler/ByteCodeUtils.java
index 4e7abf8..e08b69a 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/compiler/ByteCodeUtils.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/compiler/ByteCodeUtils.java
@@ -14,7 +14,7 @@
package com.google.devtools.build.lib.syntax.compiler;
import com.google.devtools.build.lib.syntax.compiler.Jump.PrimitiveComparison;
-
+import java.util.List;
import net.bytebuddy.description.method.MethodDescription.ForLoadedMethod;
import net.bytebuddy.description.type.TypeDescription;
import net.bytebuddy.description.type.generic.GenericTypeDescription;
@@ -26,8 +26,6 @@
import net.bytebuddy.implementation.bytecode.member.FieldAccess;
import net.bytebuddy.implementation.bytecode.member.MethodInvocation;
-import java.util.List;
-
/**
* Various utility methods for byte code generation.
*/
@@ -62,7 +60,7 @@
* <p>Exists just because {@link Compound} does not have a constructor taking a list.
*/
public static ByteCodeAppender compoundAppender(List<ByteCodeAppender> code) {
- return new Compound(code.toArray(new ByteCodeAppender[code.size()]));
+ return new Compound(code.toArray(new ByteCodeAppender[0]));
}
/**
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/compiler/VariableStore.java b/src/main/java/com/google/devtools/build/lib/syntax/compiler/VariableStore.java
index a418ad0..5ceff2f 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/compiler/VariableStore.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/compiler/VariableStore.java
@@ -16,14 +16,12 @@
import com.google.devtools.build.lib.syntax.compiler.Variable.InternalVariable;
import com.google.devtools.build.lib.syntax.compiler.Variable.SkylarkVariable;
import com.google.devtools.build.lib.util.Preconditions;
-
import net.bytebuddy.description.method.MethodDescription;
import net.bytebuddy.description.type.TypeDescription;
import net.bytebuddy.implementation.Implementation.Context;
import net.bytebuddy.implementation.bytecode.ByteCodeAppender;
import net.bytebuddy.implementation.bytecode.StackManipulation.Size;
import net.bytebuddy.implementation.bytecode.StackSize;
-
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
@@ -61,7 +59,7 @@
// TODO(klaasb) javadoc
class VariableIndexStore implements ByteCodeAppender {
- private int operandIndex;
+ private final int operandIndex;
private VariableIndexStore(int operandIndex) {
this.operandIndex = operandIndex;
