No public description

Jesse-Good · copybara-github · commit 02b8fd5cca7c · 2025-05-22T15:31:49.000-07:00
PiperOrigin-RevId: 762149697
diff --git a/java/src/com/google/template/soy/jbcsrc/ExpressionCompiler.java b/java/src/com/google/template/soy/jbcsrc/ExpressionCompiler.java
@@ -520,11 +520,9 @@ protected SoyExpression visitBooleanNode(BooleanNode node) {
 
     @Override
     protected SoyExpression visitAsOpNode(AsOpNode node) {
-      boolean mustBeBoxed = SoyRuntimeType.getUnboxedType(node.getType()).isEmpty();
-      SoyExpression value = visit(node.getChild(0));
-      if (mustBeBoxed) {
-        value = value.box();
-      }
+      // Casting requires boxing since the JVM can't just cast one primitive to another without
+      // coercing (and thus changing the underlying value).
+      SoyExpression value = visit(node.getChild(0)).box();
       return SoyExpression.forSoyValue(node.getType(), value.checkedSoyCast(node.getType()));
     }
 
diff --git a/java/src/com/google/template/soy/types/AbstractIterableType.java b/java/src/com/google/template/soy/types/AbstractIterableType.java
@@ -35,7 +35,7 @@ public SoyType getElementType() {
   public abstract boolean isEmpty();
 
   @Override
-  boolean doIsAssignableFromNonUnionType(SoyType srcType, UnknownAssignmentPolicy policy) {
+  boolean doIsAssignableFromNonUnionType(SoyType srcType, AssignabilityPolicy policy) {
     // Handle the special empty types.
     if (this == srcType) {
       return true;
diff --git a/java/src/com/google/template/soy/types/FunctionType.java b/java/src/com/google/template/soy/types/FunctionType.java
@@ -71,8 +71,7 @@ public final Kind getKind() {
   }
 
   @Override
-  final boolean doIsAssignableFromNonUnionType(
-      SoyType srcType, UnknownAssignmentPolicy unknownPolicy) {
+  final boolean doIsAssignableFromNonUnionType(SoyType srcType, AssignabilityPolicy policy) {
     if (srcType.getKind() != Kind.FUNCTION) {
       return false;
     }
@@ -86,7 +85,7 @@ final boolean doIsAssignableFromNonUnionType(
     for (int i = 0; i < paramsInCommon; i++) {
       Parameter thisParam = getParameters().get(i);
       Parameter srcParam = srcFunction.getParameters().get(i);
-      if (!srcParam.getType().isAssignableFromInternal(thisParam.getType(), unknownPolicy)) {
+      if (!srcParam.getType().isAssignableFromInternal(thisParam.getType(), policy)) {
         return false;
       }
     }
diff --git a/java/src/com/google/template/soy/types/IndexedType.java b/java/src/com/google/template/soy/types/IndexedType.java
@@ -78,7 +78,7 @@ public boolean isOriginallyOptional() {
   }
 
   @Override
-  boolean doIsAssignableFromNonUnionType(SoyType srcType, UnknownAssignmentPolicy policy) {
+  boolean doIsAssignableFromNonUnionType(SoyType srcType, AssignabilityPolicy policy) {
     return getEffectiveType().isAssignableFromInternal(srcType, policy);
   }
 }
diff --git a/java/src/com/google/template/soy/types/IntType.java b/java/src/com/google/template/soy/types/IntType.java
@@ -18,9 +18,7 @@
 
 import com.google.template.soy.soytree.SoyTypeP;
 
-/**
- * Soy integer type.
- */
+/** Soy integer type. */
 public final class IntType extends PrimitiveType {
 
   private static final IntType INSTANCE = new IntType();
@@ -34,11 +32,13 @@ public Kind getKind() {
   }
 
   @Override
-  boolean doIsAssignableFromNonUnionType(SoyType srcType) {
+  boolean doIsAssignableFromNonUnionType(SoyType srcType, AssignabilityPolicy policy) {
     Kind kind = srcType.getKind();
     // enums are implicitly assignable to ints since that is the runtime representation in all
     // backends
-    return kind == Kind.INT || kind == Kind.PROTO_ENUM || kind == Kind.NUMBER;
+    return kind == Kind.INT
+        || kind == Kind.PROTO_ENUM
+        || (policy.isNumericCoercionsAllowed() && kind == Kind.NUMBER);
   }
 
   @Override
@@ -50,6 +50,7 @@ public String toString() {
   void doToProto(SoyTypeP.Builder builder) {
     builder.setPrimitive(SoyTypeP.PrimitiveTypeP.INT);
   }
+
   /** Return the single instance of this type. */
   public static IntType getInstance() {
     return INSTANCE;
diff --git a/java/src/com/google/template/soy/types/IntersectionType.java b/java/src/com/google/template/soy/types/IntersectionType.java
@@ -74,11 +74,11 @@ public Kind getKind() {
   public abstract ImmutableSet<SoyType> getMembers();
 
   @Override
-  boolean doIsAssignableFromNonUnionType(SoyType srcType, UnknownAssignmentPolicy unknownPolicy) {
+  boolean doIsAssignableFromNonUnionType(SoyType srcType, AssignabilityPolicy policy) {
     // A type can be assigned to a union iff it is assignable to at least one
     // member of the union.
     for (SoyType memberType : getMembers()) {
-      if (!memberType.isAssignableFromInternal(srcType, unknownPolicy)) {
+      if (!memberType.isAssignableFromInternal(srcType, policy)) {
         return false;
       }
     }
diff --git a/java/src/com/google/template/soy/types/LegacyObjectMapType.java b/java/src/com/google/template/soy/types/LegacyObjectMapType.java
@@ -75,7 +75,7 @@ public SoyType getValueType() {
   }
 
   @Override
-  boolean doIsAssignableFromNonUnionType(SoyType srcType, UnknownAssignmentPolicy policy) {
+  boolean doIsAssignableFromNonUnionType(SoyType srcType, AssignabilityPolicy policy) {
     if (srcType.getKind() == Kind.LEGACY_OBJECT_MAP) {
       LegacyObjectMapType srcMapType = (LegacyObjectMapType) srcType;
       if (srcMapType == EMPTY) {
diff --git a/java/src/com/google/template/soy/types/ListType.java b/java/src/com/google/template/soy/types/ListType.java
@@ -49,7 +49,7 @@ public Kind getKind() {
   }
 
   @Override
-  boolean doIsAssignableFromNonUnionType(SoyType srcType, UnknownAssignmentPolicy policy) {
+  boolean doIsAssignableFromNonUnionType(SoyType srcType, AssignabilityPolicy policy) {
     return srcType.getKind() == Kind.LIST && super.doIsAssignableFromNonUnionType(srcType, policy);
   }
 
diff --git a/java/src/com/google/template/soy/types/MapType.java b/java/src/com/google/template/soy/types/MapType.java
@@ -97,7 +97,7 @@ public SoyType getValueType() {
   }
 
   @Override
-  boolean doIsAssignableFromNonUnionType(SoyType srcType, UnknownAssignmentPolicy policy) {
+  boolean doIsAssignableFromNonUnionType(SoyType srcType, AssignabilityPolicy policy) {
     if (srcType.getKind() == Kind.MAP) {
       MapType srcMapType = (MapType) srcType;
       if (srcMapType == EMPTY) {
diff --git a/java/src/com/google/template/soy/types/NamedType.java b/java/src/com/google/template/soy/types/NamedType.java
@@ -68,7 +68,7 @@ public SoyType getEffectiveType() {
   }
 
   @Override
-  boolean doIsAssignableFromNonUnionType(SoyType srcType, UnknownAssignmentPolicy policy) {
+  boolean doIsAssignableFromNonUnionType(SoyType srcType, AssignabilityPolicy policy) {
     return getEffectiveType().isAssignableFromInternal(srcType, policy);
   }
 }
diff --git a/java/src/com/google/template/soy/types/NumberType.java b/java/src/com/google/template/soy/types/NumberType.java
@@ -16,15 +16,11 @@
 
 package com.google.template.soy.types;
 
-import com.google.common.collect.ImmutableSet;
 import com.google.template.soy.soytree.SoyTypeP;
 
 /** Soy integer type. */
 public final class NumberType extends PrimitiveType {
 
-  private static final ImmutableSet<Kind> ASSIGNABLE_KINDS =
-      ImmutableSet.of(Kind.NUMBER, Kind.INT, Kind.FLOAT, Kind.PROTO_ENUM);
-
   private static final NumberType INSTANCE = new NumberType();
 
   // Not constructible - use getInstance().
@@ -41,8 +37,11 @@ public String toString() {
   }
 
   @Override
-  boolean doIsAssignableFromNonUnionType(SoyType srcType) {
-    return ASSIGNABLE_KINDS.contains(srcType.getKind());
+  boolean doIsAssignableFromNonUnionType(SoyType srcType, AssignabilityPolicy policy) {
+    Kind kind = srcType.getKind();
+    return kind == Kind.NUMBER
+        || kind == Kind.FLOAT
+        || (policy.isNumericCoercionsAllowed() && (kind == Kind.INT || kind == Kind.PROTO_ENUM));
   }
 
   @Override
diff --git a/java/src/com/google/template/soy/types/RecordType.java b/java/src/com/google/template/soy/types/RecordType.java
@@ -82,7 +82,7 @@ public Kind getKind() {
   }
 
   @Override
-  boolean doIsAssignableFromNonUnionType(SoyType srcType, UnknownAssignmentPolicy policy) {
+  boolean doIsAssignableFromNonUnionType(SoyType srcType, AssignabilityPolicy policy) {
     if (srcType.getKind() == Kind.RECORD) {
       RecordType srcRecord = (RecordType) srcType;
       // The source record must have at least all of the members in the dest
diff --git a/java/src/com/google/template/soy/types/SetType.java b/java/src/com/google/template/soy/types/SetType.java
@@ -49,7 +49,7 @@ public Kind getKind() {
   }
 
   @Override
-  boolean doIsAssignableFromNonUnionType(SoyType srcType, UnknownAssignmentPolicy policy) {
+  boolean doIsAssignableFromNonUnionType(SoyType srcType, AssignabilityPolicy policy) {
     return srcType.getKind() == Kind.SET && super.doIsAssignableFromNonUnionType(srcType, policy);
   }
 
diff --git a/java/src/com/google/template/soy/types/SoyType.java b/java/src/com/google/template/soy/types/SoyType.java
@@ -172,9 +172,26 @@ public boolean isIllegalOperandForBinaryOps() {
     }
   }
 
-  enum UnknownAssignmentPolicy {
-    ALLOWED,
-    DISALLOWED
+  enum AssignabilityPolicy {
+    LOOSE(true, true),
+    STRICT(false, true),
+    STRICT_WITHOUT_COERCIONS(false, false);
+
+    private final boolean unknownAssignmentAllowed;
+    private final boolean numericCoercionsAllowed;
+
+    AssignabilityPolicy(boolean unknownAssignmentAllowed, boolean numericCoercionsAllowed) {
+      this.unknownAssignmentAllowed = unknownAssignmentAllowed;
+      this.numericCoercionsAllowed = numericCoercionsAllowed;
+    }
+
+    public boolean isUnknownAssignmentAllowed() {
+      return unknownAssignmentAllowed;
+    }
+
+    public boolean isNumericCoercionsAllowed() {
+      return numericCoercionsAllowed;
+    }
   }
 
   // memoize the proto version.  SoyTypes are immutable so this is safe/correct and types are likely
@@ -201,7 +218,7 @@ enum UnknownAssignmentPolicy {
    * @return True if the assignment is valid.
    */
   public final boolean isAssignableFromLoose(SoyType srcType) {
-    return isAssignableFromInternal(srcType, UnknownAssignmentPolicy.ALLOWED);
+    return isAssignableFromInternal(srcType, AssignabilityPolicy.LOOSE);
   }
 
   /**
@@ -216,17 +233,22 @@ public final boolean isAssignableFromLoose(SoyType srcType) {
    * @return True if the assignment is valid.
    */
   public final boolean isAssignableFromStrict(SoyType srcType) {
-    return isAssignableFromInternal(srcType, UnknownAssignmentPolicy.DISALLOWED);
+    return isAssignableFromInternal(srcType, AssignabilityPolicy.STRICT);
+  }
+
+  /** Needed as long as int and number exist together. TODO(b/395679605): Remove. */
+  public final boolean isAssignableFromStrictWithoutCoercions(SoyType srcType) {
+    return isAssignableFromInternal(srcType, AssignabilityPolicy.STRICT_WITHOUT_COERCIONS);
   }
 
   /** Internal helper method for assignment analysis. This should only be used by subclasses. */
-  final boolean isAssignableFromInternal(SoyType soyType, UnknownAssignmentPolicy unknownPolicy) {
+  final boolean isAssignableFromInternal(SoyType soyType, AssignabilityPolicy policy) {
     soyType = soyType.getEffectiveType();
-    if (unknownPolicy == UnknownAssignmentPolicy.ALLOWED && soyType == UnknownType.getInstance()) {
+    if (policy.isUnknownAssignmentAllowed() && soyType == UnknownType.getInstance()) {
       return true;
     }
     if (soyType.getKind() != Kind.UNION) {
-      return doIsAssignableFromNonUnionType(soyType, unknownPolicy);
+      return doIsAssignableFromNonUnionType(soyType, policy);
     }
     // Handle unions here with template methods rather than forcing all subclasses to handle. A type
     // is assignable from a union if it is assignable from _all_ members.
@@ -245,7 +267,7 @@ final boolean isAssignableFromInternal(SoyType soyType, UnknownAssignmentPolicy
         stack.addAll(((UnionType) type).getMembers());
         continue;
       }
-      if (!doIsAssignableFromNonUnionType(type, unknownPolicy)) {
+      if (!doIsAssignableFromNonUnionType(type, policy)) {
         return false;
       }
     }
@@ -256,11 +278,11 @@ final boolean isAssignableFromInternal(SoyType soyType, UnknownAssignmentPolicy
    * Subclass integration point to implement assignablility.
    *
    * @param type The target type, guaranteed to <b>not be a union type</b>.
-   * @param unknownPolicy How assignments from the unknown type should be treated. This should be
-   *     passed along to {@link #isAssignableFromInternal} calls made on member types.
+   * @param policy How assignments from the unknown type should be treated. This should be passed
+   *     along to {@link #isAssignableFromInternal} calls made on member types.
    */
   @ForOverride
-  boolean doIsAssignableFromNonUnionType(SoyType type, UnknownAssignmentPolicy unknownPolicy) {
+  boolean doIsAssignableFromNonUnionType(SoyType type, AssignabilityPolicy policy) {
     return doIsAssignableFromNonUnionType(type);
   }
 
diff --git a/java/src/com/google/template/soy/types/SoyTypes.java b/java/src/com/google/template/soy/types/SoyTypes.java
@@ -17,6 +17,7 @@
 package com.google.template.soy.types;
 
 import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
 import static com.google.common.collect.ImmutableList.toImmutableList;
 import static com.google.common.collect.ImmutableSet.toImmutableSet;
 
@@ -34,6 +35,7 @@
 import com.google.template.soy.types.SoyType.Kind;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -105,6 +107,9 @@ private SoyTypes() {}
   public static final ImmutableSet<Kind> NUMERIC_PRIMITIVES =
       new ImmutableSet.Builder<Kind>().addAll(ARITHMETIC_PRIMITIVES).add(Kind.PROTO_ENUM).build();
 
+  public static final ImmutableSet<Kind> INTEGER_PRIMITIVES =
+      Sets.immutableEnumSet(Kind.INT, Kind.PROTO_ENUM);
+
   private static final ImmutableSet<Kind> PRIMITIVE_KINDS =
       new ImmutableSet.Builder<Kind>()
           .addAll(NUMERIC_PRIMITIVES)
@@ -242,13 +247,14 @@ public static boolean isNullOrUndefined(SoyType type) {
   }
 
   public static boolean isNumericOrUnknown(SoyType type) {
-    return type.getKind() == Kind.UNKNOWN || NUMBER_TYPE.isAssignableFromStrict(type);
+    return type.getKind() == Kind.UNKNOWN
+        || SoyTypes.isKindOrUnionOfKinds(type, SoyTypes.NUMERIC_PRIMITIVES);
   }
 
   public static Optional<SoyType> computeStricterType(SoyType t0, SoyType t1) {
-    if (t0.isAssignableFromLoose(t1)) {
+    if (t0.isAssignableFromStrictWithoutCoercions(t1)) {
       return Optional.of(t1);
-    } else if (t1.isAssignableFromStrict(t0)) {
+    } else if (t1.isAssignableFromStrictWithoutCoercions(t0)) {
       return Optional.of(t0);
     } else {
       return Optional.empty();
@@ -264,9 +270,9 @@ public static Optional<SoyType> computeStricterType(SoyType t0, SoyType t1) {
    * @return A type that is assignable from both t0 and t1.
    */
   public static SoyType computeLowestCommonType(TypeInterner typeRegistry, SoyType t0, SoyType t1) {
-    if (t0.isAssignableFromStrict(t1)) {
+    if (t0.isAssignableFromStrictWithoutCoercions(t1)) {
       return t0;
-    } else if (t1.isAssignableFromStrict(t0)) {
+    } else if (t1.isAssignableFromStrictWithoutCoercions(t0)) {
       return t1;
     } else {
       // Create a union.  This preserves the most information.
@@ -308,17 +314,27 @@ public static Optional<SoyType> computeLowestCommonTypeArithmetic(SoyType t0, So
       return Optional.empty();
     }
 
-    // Note: everything is assignable to unknown and itself.  So the first two conditions take care
-    // of all cases but a mix of float and int.
-    if (left.isAssignableFromStrict(right)) {
+    if (left.equals(right)) {
       return Optional.of(left);
-    } else if (right.isAssignableFromStrict(left)) {
-      return Optional.of(right);
-    } else {
-      // If we get here then we know that we have a mix of float and int.  In this case arithmetic
-      // ops always 'upgrade' to float.  So just return that.
-      return Optional.of(FloatType.getInstance());
     }
+    if (left.getKind() == Kind.UNKNOWN || right.getKind() == Kind.UNKNOWN) {
+      return Optional.of(UnknownType.getInstance());
+    }
+
+    // Return one of: number, float, number|int, float|int.
+    Set<SoyType> unionMembers = new HashSet<>();
+    if (SoyTypes.containsKind(left, Kind.NUMBER) || SoyTypes.containsKind(right, Kind.NUMBER)) {
+      unionMembers.add(NumberType.getInstance());
+    } else if (SoyTypes.containsKind(left, Kind.FLOAT)
+        || SoyTypes.containsKind(right, Kind.FLOAT)) {
+      unionMembers.add(FloatType.getInstance());
+    }
+    if (SoyTypes.containsKinds(left, INTEGER_PRIMITIVES)
+        && SoyTypes.containsKinds(right, INTEGER_PRIMITIVES)) {
+      unionMembers.add(IntType.getInstance());
+    }
+    checkState(!unionMembers.isEmpty()); // should be impossible due to isNumericOrUnknown.
+    return Optional.of(UnionType.of(unionMembers));
   }
 
   /**
diff --git a/java/src/com/google/template/soy/types/TemplateType.java b/java/src/com/google/template/soy/types/TemplateType.java
@@ -415,8 +415,7 @@ public final SoyType.Kind getKind() {
   }
 
   @Override
-  final boolean doIsAssignableFromNonUnionType(
-      SoyType srcType, UnknownAssignmentPolicy unknownPolicy) {
+  final boolean doIsAssignableFromNonUnionType(SoyType srcType, AssignabilityPolicy policy) {
     if (srcType.getKind() != SoyType.Kind.TEMPLATE) {
       return false;
     }
@@ -453,7 +452,7 @@ final boolean doIsAssignableFromNonUnionType(
         // of a template type is only possible when the constraints of the from-type are narrower.
         if (!srcParam
             .getCheckedType()
-            .isAssignableFromInternal(thisParam.getCheckedType(), unknownPolicy)) {
+            .isAssignableFromInternal(thisParam.getCheckedType(), policy)) {
           return false;
         }
       }
diff --git a/java/src/com/google/template/soy/types/UnionType.java b/java/src/com/google/template/soy/types/UnionType.java
diff --git a/java/tests/com/google/template/soy/passes/ResolveExpressionTypesPassTest.java b/java/tests/com/google/template/soy/passes/ResolveExpressionTypesPassTest.java
diff --git a/java/tests/com/google/template/soy/types/SoyTypesTest.java b/java/tests/com/google/template/soy/types/SoyTypesTest.java

Original file line number	Diff line number	Diff line change
`@@ -71,8 +71,7 @@ public final Kind getKind() {`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`@Override`
`74`		`- final boolean doIsAssignableFromNonUnionType(`
`75`		`- SoyType srcType, UnknownAssignmentPolicy unknownPolicy) {`
	`74`	`+ final boolean doIsAssignableFromNonUnionType(SoyType srcType, AssignabilityPolicy policy) {`
`76`	`75`	`if (srcType.getKind() != Kind.FUNCTION) {`
`77`	`76`	`return false;`
`78`	`77`	`}`
`@@ -86,7 +85,7 @@ final boolean doIsAssignableFromNonUnionType(`
`86`	`85`	`for (int i = 0; i < paramsInCommon; i++) {`
`87`	`86`	`Parameter thisParam = getParameters().get(i);`
`88`	`87`	`Parameter srcParam = srcFunction.getParameters().get(i);`
`89`		`- if (!srcParam.getType().isAssignableFromInternal(thisParam.getType(), unknownPolicy)) {`
	`88`	`+ if (!srcParam.getType().isAssignableFromInternal(thisParam.getType(), policy)) {`
`90`	`89`	`return false;`
`91`	`90`	`}`
`92`	`91`	`}`
Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,7 @@ public boolean isOriginallyOptional() {`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`@Override`
`81`		`- boolean doIsAssignableFromNonUnionType(SoyType srcType, UnknownAssignmentPolicy policy) {`
	`81`	`+ boolean doIsAssignableFromNonUnionType(SoyType srcType, AssignabilityPolicy policy) {`
`82`	`82`	`return getEffectiveType().isAssignableFromInternal(srcType, policy);`
`83`	`83`	`}`
`84`	`84`	`}`
Original file line number	Diff line number	Diff line change
`@@ -74,11 +74,11 @@ public Kind getKind() {`
`74`	`74`	`public abstract ImmutableSet<SoyType> getMembers();`
`75`	`75`
`76`	`76`	`@Override`
`77`		`- boolean doIsAssignableFromNonUnionType(SoyType srcType, UnknownAssignmentPolicy unknownPolicy) {`
	`77`	`+ boolean doIsAssignableFromNonUnionType(SoyType srcType, AssignabilityPolicy policy) {`
`78`	`78`	`// A type can be assigned to a union iff it is assignable to at least one`
`79`	`79`	`// member of the union.`
`80`	`80`	`for (SoyType memberType : getMembers()) {`
`81`		`- if (!memberType.isAssignableFromInternal(srcType, unknownPolicy)) {`
	`81`	`+ if (!memberType.isAssignableFromInternal(srcType, policy)) {`
`82`	`82`	`return false;`
`83`	`83`	`}`
`84`	`84`	`}`
Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ public SoyType getValueType() {`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`@Override`
`78`		`- boolean doIsAssignableFromNonUnionType(SoyType srcType, UnknownAssignmentPolicy policy) {`
	`78`	`+ boolean doIsAssignableFromNonUnionType(SoyType srcType, AssignabilityPolicy policy) {`
`79`	`79`	`if (srcType.getKind() == Kind.LEGACY_OBJECT_MAP) {`
`80`	`80`	`LegacyObjectMapType srcMapType = (LegacyObjectMapType) srcType;`
`81`	`81`	`if (srcMapType == EMPTY) {`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ public Kind getKind() {`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`@Override`
`52`		`- boolean doIsAssignableFromNonUnionType(SoyType srcType, UnknownAssignmentPolicy policy) {`
	`52`	`+ boolean doIsAssignableFromNonUnionType(SoyType srcType, AssignabilityPolicy policy) {`
`53`	`53`	`return srcType.getKind() == Kind.LIST && super.doIsAssignableFromNonUnionType(srcType, policy);`
`54`	`54`	`}`
`55`	`55`
Original file line number	Diff line number	Diff line change
`@@ -97,7 +97,7 @@ public SoyType getValueType() {`
`97`	`97`	`}`
`98`	`98`
`99`	`99`	`@Override`
`100`		`- boolean doIsAssignableFromNonUnionType(SoyType srcType, UnknownAssignmentPolicy policy) {`
	`100`	`+ boolean doIsAssignableFromNonUnionType(SoyType srcType, AssignabilityPolicy policy) {`
`101`	`101`	`if (srcType.getKind() == Kind.MAP) {`
`102`	`102`	`MapType srcMapType = (MapType) srcType;`
`103`	`103`	`if (srcMapType == EMPTY) {`
Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ public SoyType getEffectiveType() {`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`@Override`
`71`		`- boolean doIsAssignableFromNonUnionType(SoyType srcType, UnknownAssignmentPolicy policy) {`
	`71`	`+ boolean doIsAssignableFromNonUnionType(SoyType srcType, AssignabilityPolicy policy) {`
`72`	`72`	`return getEffectiveType().isAssignableFromInternal(srcType, policy);`
`73`	`73`	`}`
`74`	`74`	`}`