Split off SkylarkSemanticsOptions into an immutable class

This is a first step toward making the core Skylark interpreter (the syntax/ directory) not depend on the options parser. Subsequent CLs will replace uses of SkylarkSemanticsOptions within the interpreter with uses of SkylarkSemantics, and move SkylarkSemanticsOptions to the packages/ directory alongside SkylarkSemanticsCodec.

SkylarkSemantics will also replace SkylarkSemanticsOptions as the value that gets passed through Skyframe. This is nice because SkylarkSemantics is strictly immutable, whereas options classes are only kinda-sorta-immutable.

The downside is significantly more redundancy when defining new options. But some of the work is saved by using AutoValue, and there are tests that protect us from dumb mechanical errors. The details are outlined in the javadoc for SkylarkSemanticsOptions and SkylarkSemanticsConsistencyTest.

RELNOTES: None
PiperOrigin-RevId: 171060034

1 files changed, 86 insertions, 0 deletions

diff --git a/src/main/java/com/google/devtools/build/lib/packages/SkylarkSemanticsCodec.java b/src/main/java/com/google/devtools/build/lib/packages/SkylarkSemanticsCodec.java
new file mode 100644
index 0000000000..8a19ff2f52
--- /dev/null
+++ b/src/main/java/com/google/devtools/build/lib/packages/SkylarkSemanticsCodec.java
@@ -0,0 +1,86 @@
+// Copyright 2017 The Bazel Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.devtools.build.lib.packages;
+
+import com.google.devtools.build.lib.skyframe.serialization.ObjectCodec;
+import com.google.devtools.build.lib.skyframe.serialization.SerializationException;
+import com.google.devtools.build.lib.syntax.SkylarkSemantics;
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import java.io.IOException;
+
+/**
+ * Codec for a {@link SkylarkSemantics} object.
+ *
+ * <p>Since the core Skylark interpreter should not depend on the protobuf library, this codec
+ * cannot be nested alongside the {@code SkylarkSemantics} class definition.
+ *
+ * <p>Tests for this codec are in {@link SkylarkSemanticsConsistencyTest}.
+ */
+public final class SkylarkSemanticsCodec implements ObjectCodec<SkylarkSemantics> {
+
+  @Override
+  public Class<SkylarkSemantics> getEncodedClass() {
+    return SkylarkSemantics.class;
+  }
+
+  @Override
+  public void serialize(SkylarkSemantics semantics, CodedOutputStream codedOut)
+      throws SerializationException, IOException {
+    // <== Add new options here in alphabetic order ==>
+    codedOut.writeBoolNoTag(semantics.incompatibleBzlDisallowLoadAfterStatement());
+    codedOut.writeBoolNoTag(semantics.incompatibleCheckedArithmetic());
+    codedOut.writeBoolNoTag(semantics.incompatibleComprehensionVariablesDoNotLeak());
+    codedOut.writeBoolNoTag(semantics.incompatibleDepsetIsNotIterable());
+    codedOut.writeBoolNoTag(semantics.incompatibleDescriptiveStringRepresentations());
+    codedOut.writeBoolNoTag(semantics.incompatibleDictLiteralHasNoDuplicates());
+    codedOut.writeBoolNoTag(semantics.incompatibleDisallowDictPlus());
+    codedOut.writeBoolNoTag(semantics.incompatibleDisallowKeywordOnlyArgs());
+    codedOut.writeBoolNoTag(semantics.incompatibleDisallowSetConstructor());
+    codedOut.writeBoolNoTag(semantics.incompatibleDisallowToplevelIfStatement());
+    codedOut.writeBoolNoTag(semantics.incompatibleListPlusEqualsInplace());
+    codedOut.writeBoolNoTag(semantics.incompatibleLoadArgumentIsLabel());
+    codedOut.writeBoolNoTag(semantics.incompatibleNewActionsApi());
+    codedOut.writeBoolNoTag(semantics.incompatibleStringIsNotIterable());
+    codedOut.writeBoolNoTag(semantics.internalDoNotExportBuiltins());
+    codedOut.writeBoolNoTag(semantics.internalSkylarkFlagTestCanary());
+  }
+
+  @Override
+  public SkylarkSemantics deserialize(CodedInputStream codedIn)
+      throws SerializationException, IOException {
+    SkylarkSemantics.Builder builder = SkylarkSemantics.builder();
+
+    // <== Add new options here in alphabetic order ==>
+    builder.incompatibleBzlDisallowLoadAfterStatement(codedIn.readBool());
+    builder.incompatibleCheckedArithmetic(codedIn.readBool());
+    builder.incompatibleComprehensionVariablesDoNotLeak(codedIn.readBool());
+    builder.incompatibleDepsetIsNotIterable(codedIn.readBool());
+    builder.incompatibleDescriptiveStringRepresentations(codedIn.readBool());
+    builder.incompatibleDictLiteralHasNoDuplicates(codedIn.readBool());
+    builder.incompatibleDisallowDictPlus(codedIn.readBool());
+    builder.incompatibleDisallowKeywordOnlyArgs(codedIn.readBool());
+    builder.incompatibleDisallowSetConstructor(codedIn.readBool());
+    builder.incompatibleDisallowToplevelIfStatement(codedIn.readBool());
+    builder.incompatibleListPlusEqualsInplace(codedIn.readBool());
+    builder.incompatibleLoadArgumentIsLabel(codedIn.readBool());
+    builder.incompatibleNewActionsApi(codedIn.readBool());
+    builder.incompatibleStringIsNotIterable(codedIn.readBool());
+    builder.internalDoNotExportBuiltins(codedIn.readBool());
+    builder.internalSkylarkFlagTestCanary(codedIn.readBool());
+
+    return builder.build();
+  }
+}