Fix: Model with spread indexer shouldn't validate explicit properites

packages/compiler/src/core/checker.ts

@@ -5556,8 +5556,12 @@
           }),
         ],
       ];
-    } else if (target.kind === "Model" && target.indexer !== undefined && source.kind === "Model") {
-      return isIndexerValid(
+    } else if (
+      target.kind === "Model" &&
+      isArrayModelType(program, target) &&
+      source.kind === "Model"
+    ) {
+      return areIndexAreCompatible(
         source,
         target as Model & { indexer: ModelIndexer },
         diagnosticTarget,
@@ -5718,6 +5722,8 @@
   ): [Related, Diagnostic[]] {
     relationCache.set([source, target], Related.maybe);
     const diagnostics: Diagnostic[] = [];
+    const remainingProperties = new Map(source.properties);
+
     for (const prop of walkPropertiesInherited(target)) {
       const sourceProperty = getProperty(source, prop.name);
       if (sourceProperty === undefined) {
@@ -5735,6 +5741,8 @@
           );
         }
       } else {
+        remainingProperties.delete(prop.name);
+
         const [related, propDiagnostics] = isTypeAssignableToInternal(
           sourceProperty.type,
           prop.type,
@@ -5746,6 +5754,30 @@
         }
       }
     }
+
+    if (target.indexer) {
+      const [_, indexerDiagnostics] = arePropertiesAssignableToIndexer(
+        remainingProperties,
+        target.indexer.value,
+        diagnosticTarget,
+        relationCache
+      );
+      diagnostics.push(...indexerDiagnostics);
+
+      // For anonymous models we don't need an indexer
+      if (source.name !== "" && target.indexer.key.name !== "integer") {
+        const [related, indexDiagnostics] = areIndexAreCompatible(
+          source,
+          target as any,
+          diagnosticTarget,
+          relationCache
+        );
+        if (!related) {
+          diagnostics.push(...indexDiagnostics);
+        }
+      }
+    }
+
     return [diagnostics.length === 0 ? Related.true : Related.false, diagnostics];
   }
 
@@ -5756,7 +5788,57 @@
     );
   }
 
+  function arePropertiesAssignableToIndexer(
+    properties: Map<string, ModelProperty>,
+    indexerConstaint: Type,
+    diagnosticTarget: DiagnosticTarget,
+    relationCache: MultiKeyMap<[Type, Type], Related>
+  ): [Related, readonly Diagnostic[]] {
+    for (const prop of properties.values()) {
+      const [related, diagnostics] = isTypeAssignableToInternal(
+        prop.type,
+        indexerConstaint,
+        diagnosticTarget,
+        relationCache
+      );
+      if (!related) {
+        return [Related.false, diagnostics];
+      }
+    }
+
+    return [Related.true, []];
+  }
+
+  function areIndexAreCompatible(
+    source: Model,
+    target: Model & { indexer: ModelIndexer },
+    diagnosticTarget: DiagnosticTarget,
+    relationCache: MultiKeyMap<[Type | ValueType, Type | ValueType], Related>
+  ): [Related, readonly Diagnostic[]] {
+    if (source.indexer === undefined || source.indexer.key !== target.indexer.key) {
+      return [
+        Related.false,
+        [
+          createDiagnostic({
+            code: "missing-index",
+            format: {
+              indexType: getTypeName(target.indexer.key),
+              sourceType: getTypeName(source),
+            },
+            target: diagnosticTarget,
+          }),
+        ],
+      ];
+    }
+    return isTypeAssignableToInternal(
+      source.indexer.value!,
+      target.indexer.value,
+      diagnosticTarget,
+      relationCache
+    );
+  }
+
   function isIndexerValid(
     source: Model,
     target: Model & { indexer: ModelIndexer },
     diagnosticTarget: DiagnosticTarget,

packages/compiler/test/checker/relation.test.ts

@@ -650,6 +650,19 @@ describe("compiler: checker: type relations", () => {
       });
     });
 
+    it("type with spread indexer allow other properties to no match index", async () => {
+      await expectTypeAssignable({
+        source: "{age: int32, other: string}",
+        target: "Foo",
+        commonCode: `
+        model Foo {
+          age: int32;
+          ...Record<string>;
+        }
+      `,
+      });
+    });
+
     it("emit diagnostic assigning other type", async () => {
       await expectTypeNotAssignable(
         { source: `string`, target: "Record<string>" },