Value world, object, tuple literals, const

packages/compiler/src/core/checker.ts

@@ -86,6 +86,10 @@ import {
   NodeFlags,
   NumericLiteral,
   NumericLiteralNode,
+  ObjectLiteral,
+  ObjectLiteralNode,
+  ObjectLiteralProperty,
+  ObjectLiteralPropertyNode,
   Operation,
   OperationStatementNode,
   Projection,
@@ -659,6 +663,8 @@ export function createChecker(program: Program): Checker {
         return checkNamespace(node);
       case SyntaxKind.OperationStatement:
         return checkOperation(node, mapper);
+      case SyntaxKind.ObjectLiteral:
+        return checkObjectLiteral(node, mapper);
       case SyntaxKind.NumericLiteral:
         return checkNumericLiteral(node);
       case SyntaxKind.BooleanLiteral:
@@ -2948,6 +2954,79 @@ export function createChecker(program: Program): Checker {
     }
   }
 
+  function checkObjectLiteral(node: ObjectLiteralNode, mapper: TypeMapper | undefined) {
+    const type: ObjectLiteral = createType({
+      kind: "Object",
+      node: node,
+      properties: checkObjectLiteralProperties(node, mapper),
+      indexer: undefined,
+      decorators: [],
+      derivedModels: [],
+    });
+    return finishType(type);
+  }
+
+  function checkObjectLiteralProperties(node: ObjectLiteralNode, mapper: TypeMapper | undefined) {
+    const properties = createRekeyableMap<string, ObjectLiteralProperty>();
+
+    for (const prop of node.properties!) {
+      if ("id" in prop) {
+        const newProp = checkObjectLiteralProperty(prop, mapper);
+        if (newProp) {
+          properties.set(newProp.name, newProp);
+        }
+      } else {
+        const newProperties = checkObjectSpreadProperty(prop.target, mapper);
+        for (const newProp of newProperties) {
+          properties.set(newProp.name, newProp);
+        }
+      }
+    }
+    return properties;
+  }
+
+  function checkObjectLiteralProperty(
+    node: ObjectLiteralPropertyNode,
+    mapper: TypeMapper | undefined
+  ): ObjectLiteralProperty | undefined {
+    const type = getTypeForNode(node.value, mapper);
+    if (
+      type.kind !== "Object" &&
+      type.kind !== "String" &&
+      type.kind !== "Number" &&
+      type.kind !== "Boolean"
+    ) {
+      reportCheckerDiagnostic(createDiagnostic({ code: "not-literal", target: node.value }));
+      return undefined;
+    }
+
+    return createAndFinishType({
+      kind: "ObjectProperty",
+      node,
+      name: node.id.sv,
+      type: type as any,
+    });
+  }
+
+  function checkObjectSpreadProperty(
+    targetNode: TypeReferenceNode,
+    mapper: TypeMapper | undefined
+  ): ObjectLiteralProperty[] {
+    const targetType = getTypeForNode(targetNode, mapper);
+
+    if (targetType.kind === "TemplateParameter" || isErrorType(targetType)) {
+      return [];
+    }
+    // TODO: instanceof is because of conflict of the Object type from projection.
+    if (targetType.kind !== "Object" || !(targetType.properties instanceof Map)) {
+      reportCheckerDiagnostic(createDiagnostic({ code: "spread-object", target: targetNode }));
+      return [];
+    }
+
+    // TODO: do we want to clone or use the exact same reference here?
+    return [...targetType.properties.values()].map((prop) => cloneType(prop));
+  }
+
   function createUnion(options: Type[]): Union {
     const variants = createRekeyableMap<string | symbol, UnionVariant>();
     const union: Union = createAndFinishType({
@@ -5190,7 +5269,8 @@ export function createChecker(program: Program): Checker {
 
     switch (base.kind) {
       case "Object":
-        return base.properties[member] || errorType;
+        // TODO: resolve conflict here
+        return (base.properties as any)[member] || errorType;
       default:
         const typeOps = projectionMembers[base.kind];
         if (!typeOps) {

packages/compiler/src/core/messages.ts

@@ -391,12 +391,25 @@ const diagnostics = {
       selfSpread: "Cannot spread type within its own declaration.",
     },
   },
+
   "unsupported-default": {
     severity: "error",
     messages: {
       default: paramMessage`Default must be have a value type but has type '${"type"}'.`,
     },
   },
+  "spread-object": {
+    severity: "error",
+    messages: {
+      default: "Cannot spread properties of non-object type.",
+    },
+  },
+  "not-literal": {
+    severity: "error",
+    messages: {
+      default: "Type must be a literal type.",
+    },
+  },
   unassignable: {
     severity: "error",
     messages: {

packages/compiler/src/core/parser.ts

@@ -62,6 +62,9 @@ import {
   Node,
   NodeFlags,
   NumericLiteralNode,
+  ObjectLiteralNode,
+  ObjectLiteralPropertyNode,
+  ObjectLiteralSpreadPropertyNode,
   OperationSignature,
   OperationStatementNode,
   ParseOptions,
@@ -124,7 +127,12 @@ type ParseListItem<K, T> = K extends UnannotatedListKind
   ? () => T
   : (pos: number, decorators: DecoratorExpressionNode[]) => T;
 
-type OpenToken = Token.OpenBrace | Token.OpenParen | Token.OpenBracket | Token.LessThan;
+type OpenToken =
+  | Token.OpenBrace
+  | Token.OpenParen
+  | Token.OpenBracket
+  | Token.LessThan
+  | Token.HashBrace;
 type CloseToken = Token.CloseBrace | Token.CloseParen | Token.CloseBracket | Token.GreaterThan;
 type DelimiterToken = Token.Comma | Token.Semicolon;
 
@@ -186,6 +194,14 @@ namespace ListKind {
     toleratedDelimiter: Token.Comma,
   } as const;
 
+  export const ObjectLiteralProperties = {
+    ...PropertiesBase,
+    open: Token.HashBrace,
+    close: Token.CloseBrace,
+    delimiter: Token.Comma,
+    toleratedDelimiter: Token.Comma,
+  } as const;
+
   export const InterfaceMembers = {
     ...PropertiesBase,
     open: Token.OpenBrace,
@@ -954,6 +970,46 @@ function createParser(code: string | SourceFile, options: ParseOptions = {}): Pa
     };
   }
 
+  function parseObjectLiteralPropertyOrSpread(
+    pos: number,
+    decorators: DecoratorExpressionNode[]
+  ): ObjectLiteralPropertyNode | ObjectLiteralSpreadPropertyNode {
+    reportInvalidDecorators(decorators, "object literal property");
+
+    return token() === Token.Ellipsis
+      ? parseObjectLiteralSpreadProperty(pos)
+      : parseObjectLiteralProperty(pos);
+  }
+
+  function parseObjectLiteralSpreadProperty(pos: number): ObjectLiteralSpreadPropertyNode {
+    parseExpected(Token.Ellipsis);
+
+    // This could be broadened to allow any type expression
+    const target = parseReferenceExpression();
+
+    return {
+      kind: SyntaxKind.ObjectLiteralSpreadProperty,
+      target,
+      ...finishNode(pos),
+    };
+  }
+
+  function parseObjectLiteralProperty(pos: number): ObjectLiteralPropertyNode {
+    const id = parseIdentifier({
+      message: "property",
+    });
+
+    parseExpected(Token.Colon);
+    const value = parseExpression() as any; // TODO? only parse object expressions or let checker verify that?
+
+    return {
+      kind: SyntaxKind.ObjectLiteralProperty,
+      id,
+      value,
+      ...finishNode(pos),
+    };
+  }
+
   function parseScalarStatement(
     pos: number,
     decorators: DecoratorExpressionNode[]
@@ -1415,6 +1471,8 @@ function createParser(code: string | SourceFile, options: ParseOptions = {}): Pa
           const directives = parseDirectiveList();
           reportInvalidDirective(directives, "expression");
           continue;
+        case Token.HashBrace:
+          return parseObjectLiteral();
         case Token.VoidKeyword:
           return parseVoidKeyword();
         case Token.NeverKeyword:
@@ -1491,6 +1549,19 @@ function createParser(code: string | SourceFile, options: ParseOptions = {}): Pa
     };
   }
 
+  function parseObjectLiteral(): ObjectLiteralNode {
+    const pos = tokenPos();
+    const properties = parseList(
+      ListKind.ObjectLiteralProperties,
+      parseObjectLiteralPropertyOrSpread
+    );
+    return {
+      kind: SyntaxKind.ObjectLiteral,
+      properties,
+      ...finishNode(pos),
+    };
+  }
+
   function parseStringLiteral(): StringLiteralNode {
     const pos = tokenPos();
     const value = tokenValue();
@@ -3220,6 +3291,7 @@ export function visitChildren<T>(node: Node, cb: NodeCallback<T>): T | undefined
       );
     case SyntaxKind.ModelSpreadProperty:
       return visitNode(cb, node.target);
+
     case SyntaxKind.ModelStatement:
       return (
         visitEach(cb, node.decorators) ||
@@ -3362,7 +3434,12 @@ export function visitChildren<T>(node: Node, cb: NodeCallback<T>): T | undefined
       return visitNode(cb, node.head) || visitEach(cb, node.spans);
     case SyntaxKind.StringTemplateSpan:
       return visitNode(cb, node.expression) || visitNode(cb, node.literal);
-
+    case SyntaxKind.ObjectLiteral:
+      return visitEach(cb, node.properties);
+    case SyntaxKind.ObjectLiteralProperty:
+      return visitNode(cb, node.id) || visitNode(cb, node.value);
+    case SyntaxKind.ObjectLiteralSpreadProperty:
+      return visitNode(cb, node.target);
     // no children for the rest of these.
     case SyntaxKind.StringTemplateHead:
     case SyntaxKind.StringTemplateMiddle:

packages/compiler/src/core/scanner.ts

@@ -84,6 +84,7 @@ export enum Token {
   At,
   AtAt,
   Hash,
+  HashBrace,
   Star,
   ForwardSlash,
   Plus,
@@ -213,6 +214,7 @@ export const TokenDisplay = getTokenDisplayTable([
   [Token.At, "'@'"],
   [Token.AtAt, "'@@'"],
   [Token.Hash, "'#'"],
+  [Token.HashBrace, "'#{'"],
   [Token.Star, "'*'"],
   [Token.ForwardSlash, "'/'"],
   [Token.Plus, "'+'"],
@@ -511,7 +513,7 @@ export function createScanner(
           return lookAhead(1) === CharCode.At ? next(Token.AtAt, 2) : next(Token.At);
 
         case CharCode.Hash:
-          return next(Token.Hash);
+          return lookAhead(1) === CharCode.OpenBrace ? next(Token.HashBrace, 2) : next(Token.Hash);
 
         case CharCode.Plus:
           return isDigit(lookAhead(1)) ? scanSignedNumber() : next(Token.Plus);

packages/compiler/src/core/semantic-walker.ts

@@ -95,7 +95,7 @@ export function scopeNavigationToNamespace<T extends TypeListeners>(
           return ListenerFlow.NoRecursion;
         }
       }
-      return callback(x as any);
+      return (callback as any)(x as any);
     };
   }
   return wrappedListeners as any;
@@ -143,7 +143,7 @@ function createNavigationContext(
 ): NavigationContext {
   return {
     visited: new Set(),
-    emit: (key, ...args) => listeners[key]?.(...(args as [any])),
+    emit: (key, ...args) => (listeners as any)[key]?.(...(args as [any])),
     options: computeOptions(options),
   };
 }
@@ -392,6 +392,7 @@ function navigateTypeInternal(type: Type, context: NavigationContext) {
     case "Intrinsic":
     case "Number":
     case "String":
+    case "ObjectProperty":
       return;
     default:
       // Dummy const to ensure we handle all types.