Introduce primitive to filter model properties and get effective type

common/changes/@cadl-lang/compiler/get-effective-type_2022-05-16-16-00.json

@@ -0,0 +1,10 @@
+{
+  "changes": [
+    {
+      "packageName": "@cadl-lang/compiler",
+      "comment": "Add compiler API to filter model properties and get try to find equivalent named models for anonymous models",
+      "type": "minor"
+    }
+  ],
+  "packageName": "@cadl-lang/compiler"
+}

common/changes/@cadl-lang/openapi3/get-effective-type_2022-05-16-16-00.json

@@ -0,0 +1,10 @@
+{
+  "changes": [
+    {
+      "packageName": "@cadl-lang/openapi3",
+      "comment": "Find good names where possible for anonymous models that differ from named models only by properties that are not part of the schema",
+      "type": "minor"
+    }
+  ],
+  "packageName": "@cadl-lang/openapi3"
+}

packages/compiler/core/checker.ts

@@ -143,6 +143,14 @@ export interface Checker {
     value: string | number | boolean,
     node?: StringLiteralNode | NumericLiteralNode | BooleanLiteralNode
   ): StringLiteralType | NumericLiteralType | BooleanLiteralType;
+  getEffectiveModelType(
+    model: ModelType,
+    filter?: (property: ModelTypeProperty) => boolean
+  ): ModelType;
+  filterModelProperties(
+    model: ModelType,
+    filter: (property: ModelTypeProperty) => boolean
+  ): ModelType;
 
   errorType: ErrorType;
   voidType: VoidType;
@@ -302,6 +310,8 @@ export function createChecker(program: Program): Checker {
     createFunctionType,
     createLiteralType,
     finishType,
+    getEffectiveModelType,
+    filterModelProperties,
   };
 
   const projectionMembers = createProjectionMembers(checker);
@@ -886,7 +896,10 @@ export function createChecker(program: Program): Checker {
           continue;
         }
 
-        const newPropType = cloneType(prop, { sourceProperty: prop, model: intersection });
+        const newPropType = cloneType(prop, {
+          sourceProperty: prop,
+          model: intersection,
+        });
         properties.set(prop.name, newPropType);
       }
     }
@@ -1718,7 +1731,10 @@ export function createChecker(program: Program): Checker {
 
       // copy each property
       for (const prop of walkPropertiesInherited(targetType)) {
-        const newProp = cloneType(prop, { sourceProperty: prop, model: parentModel });
+        const newProp = cloneType(prop, {
+          sourceProperty: prop,
+          model: parentModel,
+        });
         props.push(newProp);
       }
     }
@@ -1735,6 +1751,19 @@ export function createChecker(program: Program): Checker {
     }
   }
 
+  function countPropertiesInherited(
+    model: ModelType,
+    filter?: (property: ModelTypeProperty) => boolean
+  ) {
+    let count = 0;
+    for (const each of walkPropertiesInherited(model)) {
+      if (!filter || filter(each)) {
+        count++;
+      }
+    }
+    return count;
+  }
+
   function checkModelProperty(prop: ModelPropertyNode, parentModel?: ModelType): ModelTypeProperty {
     const decorators = checkDecorators(prop);
     const valueType = getTypeForNode(prop.value);
@@ -3169,6 +3198,105 @@ export function createChecker(program: Program): Checker {
 
     return parts.reverse().join(".");
   }
+
+  function getEffectiveModelType(
+    model: ModelType,
+    filter?: (property: ModelTypeProperty) => boolean
+  ): ModelType {
+    if (filter) {
+      model = filterModelProperties(model, filter);
+    }
+    while (true) {
+      if (model.name) {
+        // named model
+        return model;
+      }
+
+      // We would need to change the algorithm if this doesn't hold. We
+      // assume model has no inherited properties below.
+      compilerAssert(!model.baseModel, "Anonymous model with base model.");
+
+      if (model.properties.size === 0) {
+        // empty model
+        return model;
+      }
+
+      let source: ModelType | undefined;
+
+      for (const property of model.properties.values()) {
+        const propertySource = getRootSourceModel(property);
+        if (!propertySource) {
+          // unsourced property
+          return model;
+        }
+
+        if (!source) {
+          // initialize common source from first sourced property.
+          source = propertySource;
+          continue;
+        }
+
+        if (isDerivedFrom(source, propertySource)) {
+          // OK
+        } else if (isDerivedFrom(propertySource, source)) {
+          // OK, but refine common source to derived type.
+          source = propertySource;
+        } else {
+          // different source
+          return model;
+        }
+      }
+
+      compilerAssert(source, "Should have found a common source to reach here.");
+
+      if (model.properties.size !== countPropertiesInherited(source, filter)) {
+        // source has additional properties.
+        return model;
+      }
+
+      // keep going until we reach a model that cannot be further reduced.
+      model = source;
+    }
+  }
+
+  function filterModelProperties(
+    model: ModelType,
+    filter: (property: ModelTypeProperty) => boolean
+  ): ModelType {
+    let filtered = false;
+    for (const property of walkPropertiesInherited(model)) {
+      if (!filter(property)) {
+        filtered = true;
+        break;
+      }
+    }
+
+    if (!filtered) {
+      return model;
+    }
+
+    const properties = new Map<string, ModelTypeProperty>();
+    const newModel: ModelType = createType({
+      kind: "Model",
+      node: undefined,
+      name: "",
+      properties,
+      decorators: [],
+      derivedModels: [],
+    });
+
+    for (const property of walkPropertiesInherited(model)) {
+      if (filter(property)) {
+        const newProperty = cloneType(property, {
+          sourceProperty: property,
+          model: newModel,
+        });
+        properties.set(property.name, newProperty);
+      }
+    }
+
+    return finishType(newModel);
+  }
 }
 
 function isErrorType(type: Type): type is ErrorType {
@@ -3178,3 +3306,20 @@ function isErrorType(type: Type): type is ErrorType {
 function createUsingSymbol(symbolSource: Sym): Sym {
   return { flags: SymbolFlags.Using, declarations: [], name: symbolSource.name, symbolSource };
 }
+
+function isDerivedFrom(derived: ModelType, base: ModelType) {
+  while (derived !== base && derived.baseModel) {
+    derived = derived.baseModel;
+  }
+  return derived === base;
+}
+
+function getRootSourceModel(property: ModelTypeProperty): ModelType | undefined {
+  if (!property.sourceProperty) {
+    return undefined;
+  }
+  while (property.sourceProperty) {
+    property = property.sourceProperty;
+  }
+  return property?.model;
+}

packages/compiler/core/projector.ts

@@ -269,8 +269,8 @@ export function createProjector(
    */
   function shouldFinishType(type: ModelType | InterfaceType | UnionType) {
     if (
-      type.node.kind !== SyntaxKind.ModelStatement &&
-      type.node.kind !== SyntaxKind.InterfaceStatement
+      type.node?.kind !== SyntaxKind.ModelStatement &&
+      type.node?.kind !== SyntaxKind.InterfaceStatement
     ) {
       return true;
     }

packages/compiler/core/semantic-walker.ts

@@ -258,7 +258,7 @@ function navigateType(
  */
 export function isTemplate(model: ModelType): boolean {
   return (
-    model.node.kind === SyntaxKind.ModelStatement &&
+    model.node?.kind === SyntaxKind.ModelStatement &&
     model.node.templateParameters.length > 0 &&
     !model.templateArguments?.length
   );

packages/compiler/core/types.ts

@@ -8,7 +8,7 @@ export type DecoratorArgumentValue = Type | number | string | boolean;
 
 export interface DecoratorArgument {
   value: DecoratorArgumentValue;
-  node: Node;
+  node?: Node;
 }
 
 export interface DecoratorApplication {
@@ -149,7 +149,7 @@ export type IntrinsicModel<T extends IntrinsicModelName = IntrinsicModelName> =
 export interface ModelType extends BaseType, DecoratedType, TemplatedType {
   kind: "Model";
   name: IntrinsicModelName | string;
-  node:
+  node?:
     | ModelStatementNode
     | ModelExpressionNode
     | IntersectionExpressionNode