Add simple optimization type ("color") system

This is not full-featured and can be expanded later on.

PiperOrigin-RevId: 321186327

Author: lauraharker

BUILD.bazel

@@ -41,6 +41,7 @@ j2cl_library(
             "src/com/google/debugging/**/*.js",
             "src/com/google/javascript/rhino/**/*.java",
             "src/com/google/javascript/jscomp/*.java",
+            "src/com/google/javascript/jscomp/colors/**/*.java",
             "src/com/google/javascript/jscomp/deps/**/*.java",
             "src/com/google/javascript/jscomp/lint/**/*.java",
             "src/com/google/javascript/jscomp/ijs/**/*.java",

src/com/google/javascript/jscomp/colors/Color.java

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2020 The Closure Compiler Authors.
+ *
+ * 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.javascript.jscomp.colors;
+
+import com.google.common.collect.ImmutableCollection;
+
+/** A simplified version of a Closure or TS type for use by optimizations */
+public interface Color {
+
+  boolean isPrimitive();
+
+  boolean isUnion();
+
+  ImmutableCollection<Color> getAlternates();
+}

src/com/google/javascript/jscomp/colors/PrimitiveColor.java

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2020 The Closure Compiler Authors.
+ *
+ * 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.javascript.jscomp.colors;
+
+import com.google.common.collect.ImmutableCollection;
+
+/** Value types that are a) not user-defined and b) do not need individual classes */
+public enum PrimitiveColor implements Color {
+  // JS primitive types
+  NUMBER,
+  STRING,
+  SYMBOL,
+  NULL_OR_VOID,
+  BIGINT,
+  // Equivalent to Closure '*'/'?' and TS unknown/any
+  UNKNOWN;
+
+  @Override
+  public boolean isPrimitive() {
+    return true;
+  }
+
+  @Override
+  public boolean isUnion() {
+    return false;
+  }
+
+  @Override
+  public ImmutableCollection<Color> getAlternates() {
+    // In theory we could consider a primitive a union of a single value. It's not clear whether
+    // that would be simpler or not.
+    throw new UnsupportedOperationException("Can only call getAlternates() on unions");
+  }
+}

src/com/google/javascript/jscomp/colors/UnionColor.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2020 The Closure Compiler Authors.
+ *
+ * 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.javascript.jscomp.colors;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.collect.ImmutableCollection;
+import com.google.common.collect.ImmutableSet;
+
+/** A set of multiple {@link Color}s. */
+@AutoValue
+public abstract class UnionColor implements Color {
+
+  static UnionColor create(ImmutableSet<Color> alternates) {
+    checkArgument(
+        alternates.size() > 1,
+        "UnionColor alternates should have more than one element, found %s",
+        alternates);
+    // Flatten other UnionColors
+    ImmutableSet.Builder<Color> flatAlternates = ImmutableSet.builder();
+    for (Color alternate : alternates) {
+      if (alternate.isUnion()) {
+        flatAlternates.addAll(alternate.getAlternates());
+      } else {
+        flatAlternates.add(alternate);
+      }
+    }
+    return new AutoValue_UnionColor(flatAlternates.build());
+  }
+
+  @Override
+  public boolean isPrimitive() {
+    return false;
+  }
+
+  @Override
+  public boolean isUnion() {
+    return true;
+  }
+
+  @Override
+  public abstract ImmutableCollection<Color> getAlternates();
+}

src/com/google/javascript/jscomp/testing/ColorSubject.java

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2020 The Closure Compiler Authors.
+ *
+ * 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.javascript.jscomp.testing;
+
+import static com.google.common.truth.Truth.assertAbout;
+
+import com.google.common.truth.FailureMetadata;
+import com.google.common.truth.Subject;
+import com.google.javascript.jscomp.colors.Color;
+import javax.annotation.Nullable;
+
+/** Subject for {@link Color} */
+public final class ColorSubject extends Subject {
+
+  @Nullable private final Color actual;
+
+  private ColorSubject(FailureMetadata metadata, @Nullable Color actual) {
+    super(metadata, actual);
+    this.actual = actual;
+  }
+
+  public static Factory<ColorSubject, Color> colors() {
+    return ColorSubject::new;
+  }
+
+  public static ColorSubject assertThat(@Nullable Color actual) {
+    return assertAbout(colors()).that(actual);
+  }
+
+  private Color actualNonNull() {
+    isNotNull();
+    return actual;
+  }
+
+  // Custom assertions
+
+  public void isPrimitive() {
+    check("isPrimitive").that(actualNonNull().isPrimitive()).isTrue();
+  }
+
+  public void isUnion() {
+    check("isUnion").that(actualNonNull().isUnion()).isTrue();
+  }
+
+  public void hasAlternates(Color... alternates) {
+    isUnion();
+    check("getAlternates().containsExactly()")
+        .that(actualNonNull().getAlternates())
+        // cast to Object[] to suppress warning about varargs vs. non-varargs call confusion
+        .containsExactly((Object[]) alternates);
+  }
+}

test/com/google/javascript/jscomp/colors/PrimitiveColorTest.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2020 The Closure Compiler Authors.
+ *
+ * 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.javascript.jscomp.colors;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.javascript.jscomp.testing.ColorSubject.assertThat;
+import static com.google.javascript.rhino.testing.Asserts.assertThrows;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class PrimitiveColorTest {
+  @Test
+  public void isPrimitiveReturnsTrue() {
+    assertThat((Color) PrimitiveColor.NUMBER).isPrimitive();
+    assertThat((Color) PrimitiveColor.UNKNOWN).isPrimitive();
+  }
+
+  @Test
+  public void isUnionReturnsFalse() {
+    assertThat(PrimitiveColor.NUMBER.isUnion()).isFalse();
+    assertThat(PrimitiveColor.NULL_OR_VOID.isUnion()).isFalse();
+    assertThat(PrimitiveColor.UNKNOWN.isUnion()).isFalse();
+  }
+
+  @Test
+  public void getAlternatesIsNotAllowed() {
+    assertThrows(Exception.class, PrimitiveColor.NUMBER::getAlternates);
+  }
+}

test/com/google/javascript/jscomp/colors/UnionColorTest.java

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2020 The Closure Compiler Authors.
+ *
+ * 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.javascript.jscomp.colors;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.javascript.jscomp.testing.ColorSubject.assertThat;
+import static com.google.javascript.rhino.testing.Asserts.assertThrows;
+
+import com.google.common.collect.ImmutableSet;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class UnionColorTest {
+  @Test
+  public void isPrimitiveReturnsFalse() {
+    UnionColor numberOrString =
+        UnionColor.create(ImmutableSet.of(PrimitiveColor.STRING, PrimitiveColor.NUMBER));
+
+    assertThat(numberOrString.isPrimitive()).isFalse();
+  }
+
+  @Test
+  public void isUnionHandlesReturnsTrue() {
+    UnionColor union =
+        UnionColor.create(ImmutableSet.of(PrimitiveColor.NUMBER, PrimitiveColor.STRING));
+
+    assertThat(union).isUnion();
+  }
+
+  @Test
+  public void getAlternatesReturnsAlternatesList() {
+    UnionColor union =
+        UnionColor.create(ImmutableSet.of(PrimitiveColor.NUMBER, PrimitiveColor.STRING));
+
+    assertThat(union).hasAlternates(PrimitiveColor.NUMBER, PrimitiveColor.STRING);
+  }
+
+  @Test
+  public void alternatesMayContainOtherUnion() {
+    UnionColor union =
+        UnionColor.create(ImmutableSet.of(PrimitiveColor.NUMBER, PrimitiveColor.STRING));
+    UnionColor newUnion = UnionColor.create(ImmutableSet.of(union, PrimitiveColor.BIGINT));
+
+    assertThat(newUnion)
+        .hasAlternates(PrimitiveColor.STRING, PrimitiveColor.BIGINT, PrimitiveColor.NUMBER);
+  }
+
+  @Test
+  public void alternatesAreDeduplicatedFromOtherUnion() {
+    UnionColor union =
+        UnionColor.create(
+            ImmutableSet.of(
+                PrimitiveColor.NUMBER,
+                UnionColor.create(ImmutableSet.of(PrimitiveColor.NUMBER, PrimitiveColor.STRING))));
+
+    assertThat(union).hasAlternates(PrimitiveColor.NUMBER, PrimitiveColor.STRING);
+  }
+
+  @Test
+  public void createMethodRequiresTwoOrMoreAlternates() {
+    assertThrows(IllegalArgumentException.class, () -> UnionColor.create(ImmutableSet.of()));
+    assertThrows(
+        IllegalArgumentException.class,
+        () -> UnionColor.create(ImmutableSet.of(PrimitiveColor.NUMBER)));
+  }
+
+  @Test
+  public void unknownTypeIsNotSpecialCased() {
+    // In some "check" type systems, the top type + another type is equivalent to just the
+    // top type. Colors don't replicate those semantics. Whatever serialized type structure the
+    // colors are created from has already dealt with this.
+    UnionColor union =
+        UnionColor.create(ImmutableSet.of(PrimitiveColor.UNKNOWN, PrimitiveColor.STRING));
+
+    assertThat(union).isUnion();
+    assertThat(union.getAlternates()).hasSize(2);
+  }
+}