Support object spread in the type checker.

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=229439222

src/com/google/javascript/jscomp/TypeCheck.java

@@ -1006,6 +1006,11 @@ public void visit(NodeTraversal t, Node n, Node parent) {
   }
 
   private void checkSpread(NodeTraversal t, Node spreadNode) {
+    if (spreadNode.getParent().isObjectLit()) {
+      // Nothing to check for object spread, anything can be spread.
+      return;
+    }
+
     Node iterableNode = spreadNode.getOnlyChild();
     ensureTyped(iterableNode);
     JSType iterableType = getJSType(iterableNode);
@@ -1328,7 +1333,7 @@ private void visitObjectPattern(NodeTraversal t, Node pattern) {
    * we change the schema of the object type it is referring to.
    *
    * @param t the traversal
-   * @param key the ASSIGN, STRING_KEY, MEMBER_FUNCTION_DEF, or COMPUTED_PROPERTY node
+   * @param key the ASSIGN, STRING_KEY, MEMBER_FUNCTION_DEF, SPREAD, or COMPUTED_PROPERTY node
    * @param owner the parent node, either OBJECTLIT or CLASS_MEMBERS
    * @param ownerType the instance type of the enclosing object/class
    */
@@ -1371,6 +1376,11 @@ private void visitObjectOrClassLiteralKey(
       }
     }
 
+    if (key.isSpread()) {
+      // Rely on type inference to figure out what the key/types this adds to this object.
+      return;
+    }
+
     // TODO(johnlenz): Validate get and set function declarations are valid
     // as is the functions can have "extraneous" bits.
 

src/com/google/javascript/jscomp/TypeInference.java

@@ -1333,26 +1333,52 @@ private FlowScope traverseObjectLiteral(Node n, FlowScope scope) {
       return scope;
     }
 
-    String qObjName = NodeUtil.getBestLValueName(
-        NodeUtil.getBestLValue(n));
-    for (Node name = n.getFirstChild(); name != null;
-         name = name.getNext()) {
-      if (name.isComputedProp()) {
+    String qObjName = NodeUtil.getBestLValueName(NodeUtil.getBestLValue(n));
+    for (Node key = n.getFirstChild(); key != null; key = key.getNext()) {
+      if (key.isComputedProp()) {
         // Don't define computed properties as inferred properties on the object
         continue;
       }
-      String memberName = NodeUtil.getObjectLitKeyName(name);
+
+      if (key.isSpread()) {
+        Node name = key.getFirstChild();
+        JSType nameType = name.getJSType();
+
+        if (nameType == null) {
+          continue;
+        }
+
+        ObjectType spreadType = nameType.toMaybeObjectType();
+
+        while (spreadType != null) {
+          Set<String> spreadPropertyNames = spreadType.getOwnPropertyNames();
+          for (String propertyName : spreadPropertyNames) {
+            objectType.defineInferredProperty(
+                propertyName, spreadType.getPropertyType(propertyName), key);
+          }
+          if ((!spreadType.isConstructor()
+                  && !spreadType.isInterface()
+                  && !spreadType.isInstanceType())
+              || spreadType.getSuperClassConstructor() == null) {
+            break;
+          }
+          spreadType = spreadType.getSuperClassConstructor().getInstanceType();
+        }
+
+        continue;
+      }
+
+      String memberName = NodeUtil.getObjectLitKeyName(key);
       if (memberName != null) {
-        JSType rawValueType =  name.getFirstChild().getJSType();
-        JSType valueType =
-            TypeCheck.getObjectLitKeyTypeFromValueType(name, rawValueType);
+        JSType rawValueType = key.getFirstChild().getJSType();
+        JSType valueType = TypeCheck.getObjectLitKeyTypeFromValueType(key, rawValueType);
         if (valueType == null) {
           valueType = unknownType;
         }
-        objectType.defineInferredProperty(memberName, valueType, name);
+        objectType.defineInferredProperty(memberName, valueType, key);
 
         // Do normal flow inference if this is a direct property assignment.
-        if (qObjName != null && name.isStringKey()) {
+        if (qObjName != null && key.isStringKey()) {
           String qKeyName = qObjName + "." + memberName;
           TypedVar var = getDeclaredVar(scope, qKeyName);
           JSType oldType = var == null ? null : var.getType();
@@ -1362,7 +1388,7 @@ private FlowScope traverseObjectLiteral(Node n, FlowScope scope) {
 
           scope =
               scope.inferQualifiedSlot(
-                  name, qKeyName, oldType == null ? unknownType : oldType, valueType, false);
+                  key, qKeyName, oldType == null ? unknownType : oldType, valueType, false);
         }
       } else {
         n.setJSType(unknownType);

src/com/google/javascript/jscomp/TypedScopeCreator.java

@@ -750,8 +750,10 @@ void processObjectLitProperties(
         Node objLit, ObjectType objLitType,
         boolean declareOnOwner) {
       for (Node keyNode = objLit.getFirstChild(); keyNode != null; keyNode = keyNode.getNext()) {
-        if (keyNode.isComputedProp()) {
-          // Don't try defining computed properties on an object.
+        if (keyNode.isComputedProp() || keyNode.isSpread()) {
+          // Don't try defining computed or spread properties on an object. Note that for spread
+          // type inference will try to determine the properties and types. We cannot do it here as
+          // we don't have all the type information of the spread object.
           continue;
         }
         Node value = keyNode.getFirstChild();