fix: correct Sym.node and getSymNode types to include undefined

.chronus/changes/fix-sym-node-undefined-2026-5-6-18-23-0.md

@@ -0,0 +1,7 @@
+---
+changeKind: fix
+packages:
+  - "@typespec/compiler"
+---
+
+Fix `Sym.node` type to be `Node | undefined` and update `getSymNode` return type to accurately reflect that it may return `undefined` for symbols created without a node (e.g. the built-in `null` symbol). Update all callers to correctly handle the `undefined` case.

packages/compiler/src/core/binder.ts

@@ -705,6 +705,6 @@ export function createSymbol(
  * If a declaration symbol get the first one `.declarations[0]`
  * Otherwise get `.node`
  */
-export function getSymNode(sym: Sym): Node {
+export function getSymNode(sym: Sym): Node | undefined {
   return sym.flags & SymbolFlags.Declaration ? sym.declarations[0] : sym.node;
 }

packages/compiler/src/core/checker.ts

@@ -682,15 +682,19 @@ export function createChecker(program: Program, resolver: NameResolver): Checker
    */
   function checkMemberSym(ctx: CheckContext, sym: Sym): Type {
     const symbolLinks = getSymbolLinks(sym);
-    const memberContainer = getTypeForNode(getSymNode(sym.parent!), ctx);
+    const parentNode = getSymNode(sym.parent!);
+    compilerAssert(parentNode, "Expected member container parent symbol to have a node");
+    const memberContainer = getTypeForNode(parentNode, ctx);
     const type = symbolLinks.declaredType ?? symbolLinks.type;
 
     if (type) {
       return type;
     } else {
+      const memberNode = getSymNode(sym);
+      compilerAssert(memberNode, "Expected member symbol to have a node");
       return checkMember(
         ctx,
-        getSymNode(sym) as MemberNode,
+        memberNode as MemberNode,
         memberContainer as MemberContainerType,
       )!;
     }
@@ -1737,6 +1741,7 @@ export function createChecker(program: Program, resolver: NameResolver): Checker
         compilerAssert(sym.type, `Expected late bound symbol to have type`);
         return sym.type;
       } else if (sym.flags & SymbolFlags.TemplateParameter) {
+        compilerAssert(symNode, "Expected template parameter symbol to have a node");
         const mapped = checkTemplateParameterDeclaration(
           ctx,
           symNode as TemplateParameterDeclarationNode,
@@ -1752,6 +1757,7 @@ export function createChecker(program: Program, resolver: NameResolver): Checker
           baseType = checkMemberSym(ctx, sym);
         } else {
           // don't have a cached type for this symbol, so go grab it and cache it
+          compilerAssert(symNode, "Expected symbol to have a node to resolve type");
           baseType = getTypeForNode(symNode, ctx);
           symbolLinks.type = baseType;
         }
@@ -3605,8 +3611,8 @@ export function createChecker(program: Program, resolver: NameResolver): Checker
     return undefined;
   }
 
-  function getMemberKindName(node: Node) {
-    switch (node.kind) {
+  function getMemberKindName(node: Node | undefined) {
+    switch (node?.kind) {
       case SyntaxKind.ModelStatement:
       case SyntaxKind.ModelExpression:
         return "Model";
@@ -3631,6 +3637,7 @@ export function createChecker(program: Program, resolver: NameResolver): Checker
    */
   function getAliasedSymbol(ctx: CheckContext, aliasSymbol: Sym): Sym | undefined {
     const node = getSymNode(aliasSymbol);
+    compilerAssert(node, "Expected alias symbol to have a node");
     const links = resolver.getSymbolLinks(aliasSymbol);
     if (!links.aliasResolutionIsTemplate) {
       return links.aliasedSymbol ?? resolver.getNodeLinks(node).resolvedSymbol;
@@ -6036,7 +6043,8 @@ export function createChecker(program: Program, resolver: NameResolver): Checker
         }),
       );
     } else if (links.finalSymbol?.flags && links.finalSymbol.flags & SymbolFlags.Alias) {
-      const aliasNode: AliasStatementNode = getSymNode(links.finalSymbol) as AliasStatementNode;
+      const aliasNode = getSymNode(links.finalSymbol) as AliasStatementNode | undefined;
+      compilerAssert(aliasNode, "Expected alias symbol to have a node");
 
       program.reportDiagnostic(
         createDiagnostic({
@@ -7653,7 +7661,8 @@ function createFunctionContext(program: Program, fnCall: CallExpressionNode): Fu
   };
 }
 
-function isTemplatedNode(node: Node): node is TemplateableNode {
+function isTemplatedNode(node: Node | undefined): node is TemplateableNode {
+  if (node === undefined) return false;
   return "templateParameters" in node && node.templateParameters.length > 0;
 }
 

packages/compiler/src/core/name-resolver.ts

@@ -715,6 +715,10 @@ export function createResolver(program: Program): NameResolver {
   function resolveMetaMemberByName(baseSym: Sym, sv: string): ResolutionResult {
     const baseNode = getSymNode(baseSym);
 
+    if (!baseNode) {
+      return failedResult(ResolutionResultFlags.NotFound);
+    }
+
     const prototype = metaTypePrototypes.get(baseNode.kind);
 
     if (!prototype) {
@@ -1322,8 +1326,9 @@ export function createResolver(program: Program): NameResolver {
     // model properties
     const modelPropertyPrototype: TypePrototype = new Map();
     modelPropertyPrototype.set("type", (baseSym) => {
-      const node = baseSym.node as ModelPropertyNode;
-      return resolveExpression(node.value);
+      const node = getSymNode(baseSym);
+      compilerAssert(node, "Expected model property symbol to have a node");
+      return resolveExpression((node as ModelPropertyNode).value);
     });
     nodeInterfaces.set(SyntaxKind.ModelProperty, modelPropertyPrototype);
 

packages/compiler/src/core/types.ts

@@ -847,8 +847,9 @@ export interface Sym {
 
   /**
    * Node which resulted in this symbol, present if SymbolFlags.Declaration is not set.
+   * May be undefined if the symbol was created without a node (e.g. built-in symbols like `null`).
    */
-  readonly node: Node;
+  readonly node: Node | undefined;
 
   /**
    * The name of the symbol