Extend LSP hover to lambda params, constructors, and qualified names

- Add paramSpan to CAbs for lambda parameter hover support
- Track constructor definitions/references via constructorIds map
- Add moduleSpan/memberSpan to CVar for qualified name hover (e.g., String.concat)
- Add fieldSpan to SField for member access tracking
- Fix basics test: use single quotes for char literals ('a' not "a")

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: brielov

integration/basics/main.alg

@@ -258,10 +258,10 @@ let testCons =
 -- =============================================================================
 
 let testChars =
-  let c1 = "a" in
-  let c2 = "Z" in
-  let c3 = "5" in
-  let c4 = " " in
+  let c1 = 'a' in
+  let c2 = 'Z' in
+  let c3 = '5' in
+  let c4 = ' ' in
   let a = if Char.isAlpha c1 then 1 else 0 in        -- 1
   let b = if Char.isAlpha c3 then 1 else 0 in        -- 0
   let c = if Char.isDigit c3 then 1 else 0 in        -- 1

src/compile.ts

@@ -410,6 +410,7 @@ const offsetExpr = (expr: SExpr, offset: number): SExpr => {
     case "SAbs":
       return {
         ...expr,
+        params: expr.params.map((p) => ({ ...p, span: offsetSpan(p.span, offset) })),
         body: offsetExpr(expr.body, offset),
         span: offsetSpan(expr.span, offset),
       };
@@ -419,11 +420,16 @@ const offsetExpr = (expr: SExpr, offset: number): SExpr => {
         value: offsetExpr(expr.value, offset),
         body: offsetExpr(expr.body, offset),
         span: offsetSpan(expr.span, offset),
+        nameSpan: offsetSpan(expr.nameSpan, offset),
       };
     case "SLetRec":
       return {
         ...expr,
-        bindings: expr.bindings.map((b) => ({ ...b, value: offsetExpr(b.value, offset) })),
+        bindings: expr.bindings.map((b) => ({
+          ...b,
+          value: offsetExpr(b.value, offset),
+          nameSpan: offsetSpan(b.nameSpan, offset),
+        })),
         body: offsetExpr(expr.body, offset),
         span: offsetSpan(expr.span, offset),
       };
@@ -468,6 +474,7 @@ const offsetExpr = (expr: SExpr, offset: number): SExpr => {
         ...expr,
         record: offsetExpr(expr.record, offset),
         span: offsetSpan(expr.span, offset),
+        fieldSpan: offsetSpan(expr.fieldSpan, offset),
       };
     case "SList":
       return {
@@ -521,6 +528,7 @@ const offsetDecl = (decl: SDecl, offset: number): SDecl => {
         constructors: decl.constructors.map((c) => ({
           ...c,
           fields: c.fields.map((f) => offsetType(f, offset)),
+          span: offsetSpan(c.span, offset),
         })),
         span: offsetSpan(decl.span, offset),
       };

src/core.ts

@@ -46,6 +46,9 @@ export type CVar = {
   readonly kind: "CVar";
   readonly name: Name;
   readonly span?: Span;
+  // For qualified names (Module.member), track the spans separately
+  readonly moduleSpan?: Span;
+  readonly memberSpan?: Span;
 };
 
 export type CLit = {
@@ -67,6 +70,7 @@ export type CAbs = {
   readonly param: Name;
   readonly body: CExpr;
   readonly span?: Span;
+  readonly paramSpan?: Span;
 };
 
 export type CLet = {
@@ -75,11 +79,16 @@ export type CLet = {
   readonly value: CExpr;
   readonly body: CExpr;
   readonly span?: Span;
+  readonly nameSpan?: Span;
 };
 
 export type CLetRec = {
   readonly kind: "CLetRec";
-  readonly bindings: readonly { readonly name: Name; readonly value: CExpr }[];
+  readonly bindings: readonly {
+    readonly name: Name;
+    readonly value: CExpr;
+    readonly nameSpan?: Span;
+  }[];
   readonly body: CExpr;
   readonly span?: Span;
 };
@@ -257,6 +266,7 @@ export type CDeclType = {
 export type CConDecl = {
   readonly name: string;
   readonly fields: readonly CType[];
+  readonly span?: Span;
 };
 
 export type CDeclLet = {
@@ -301,29 +311,43 @@ export type CProgram = {
 // Smart Constructors
 // =============================================================================
 
-export const cvar = (name: Name, span?: Span): CVar => ({ kind: "CVar", name, span });
+export const cvar = (name: Name, span?: Span, moduleSpan?: Span, memberSpan?: Span): CVar => ({
+  kind: "CVar",
+  name,
+  span,
+  moduleSpan,
+  memberSpan,
+});
 export const clit = (value: Literal, span?: Span): CLit => ({ kind: "CLit", value, span });
 export const capp = (func: CExpr, arg: CExpr, span?: Span): CApp => ({
   kind: "CApp",
   func,
   arg,
   span,
 });
-export const cabs = (param: Name, body: CExpr, span?: Span): CAbs => ({
+export const cabs = (param: Name, body: CExpr, span?: Span, paramSpan?: Span): CAbs => ({
   kind: "CAbs",
   param,
   body,
   span,
+  paramSpan,
 });
-export const clet = (name: Name, value: CExpr, body: CExpr, span?: Span): CLet => ({
+export const clet = (
+  name: Name,
+  value: CExpr,
+  body: CExpr,
+  span?: Span,
+  nameSpan?: Span,
+): CLet => ({
   kind: "CLet",
   name,
   value,
   body,
   span,
+  nameSpan,
 });
 export const cletrec = (
-  bindings: readonly { name: Name; value: CExpr }[],
+  bindings: readonly { name: Name; value: CExpr; nameSpan?: Span }[],
   body: CExpr,
   span?: Span,
 ): CLetRec => ({ kind: "CLetRec", bindings, body, span });

src/desugar.ts

@@ -49,6 +49,7 @@ export const desugarExpr = (expr: S.SExpr): C.CExpr => {
         desugarExpr(expr.value),
         desugarExpr(expr.body),
         expr.span,
+        expr.nameSpan,
       );
 
     case "SLetRec":
@@ -57,6 +58,7 @@ export const desugarExpr = (expr: S.SExpr): C.CExpr => {
         expr.bindings.map((b) => ({
           name: { id: -1, original: b.name },
           value: desugarExpr(b.value),
+          nameSpan: b.nameSpan,
         })),
         desugarExpr(expr.body),
         expr.span,
@@ -120,7 +122,13 @@ export const desugarExpr = (expr: S.SExpr): C.CExpr => {
         if (expr.field[0] && expr.field[0] === expr.field[0].toUpperCase()) {
           return C.ccon(qualifiedName, expr.span);
         }
-        return C.cvar({ id: -1, original: qualifiedName }, expr.span);
+        // Pass module span (from the constructor) and member span (from the field)
+        return C.cvar(
+          { id: -1, original: qualifiedName },
+          expr.span,
+          expr.record.span,
+          expr.fieldSpan,
+        );
       }
       // D⟦ SField e f ⟧ = CField (D⟦e⟧) f
       return C.cfield(desugarExpr(expr.record), expr.field, expr.span);
@@ -200,15 +208,21 @@ export const desugarExpr = (expr: S.SExpr): C.CExpr => {
 // Helper Functions
 // =============================================================================
 
-const desugarAbs = (params: readonly string[], body: S.SExpr, span?: S.Span): C.CExpr => {
+const desugarAbs = (params: readonly S.SParam[], body: S.SExpr, span?: S.Span): C.CExpr => {
   if (params.length === 0) {
     return desugarExpr(body);
   }
 
   // Build nested lambdas from right to left
   let result = desugarExpr(body);
   for (let i = params.length - 1; i >= 0; i--) {
-    result = C.cabs({ id: -1, original: params[i]! }, result, i === 0 ? span : undefined);
+    const param = params[i]!;
+    result = C.cabs(
+      { id: -1, original: param.name },
+      result,
+      i === 0 ? span : undefined,
+      param.span,
+    );
   }
   return result;
 };
@@ -535,6 +549,7 @@ const desugarDecl = (decl: S.SDecl): C.CDecl | C.CDecl[] | null => {
         decl.constructors.map((c) => ({
           name: c.name,
           fields: c.fields.map(desugarType),
+          span: c.span,
         })),
         decl.span,
       );
@@ -728,6 +743,7 @@ const desugarExprInModuleWithImports = (
           shadowedImportedNames,
         ),
         expr.span,
+        expr.nameSpan,
       );
     }
 
@@ -745,6 +761,7 @@ const desugarExprInModuleWithImports = (
         expr.bindings.map((b) => ({
           name: { id: -1, original: b.name },
           value: recurseWithShadow(b.value),
+          nameSpan: b.nameSpan,
         })),
         recurseWithShadow(expr.body),
         expr.span,
@@ -839,7 +856,13 @@ const desugarExprInModuleWithImports = (
         if (expr.field[0] && expr.field[0] === expr.field[0].toUpperCase()) {
           return C.ccon(qualifiedName, expr.span);
         }
-        return C.cvar({ id: -1, original: qualifiedName }, expr.span);
+        // Pass module span (from the constructor) and member span (from the field)
+        return C.cvar(
+          { id: -1, original: qualifiedName },
+          expr.span,
+          expr.record.span,
+          expr.fieldSpan,
+        );
       }
       return C.cfield(recurse(expr.record), expr.field, expr.span);
 
@@ -913,7 +936,7 @@ const desugarExprInModuleWithImports = (
 };
 
 const desugarAbsInModuleWithImports = (
-  params: readonly string[],
+  params: readonly S.SParam[],
   body: S.SExpr,
   moduleName: string,
   moduleNames: Set<string>,
@@ -928,8 +951,8 @@ const desugarAbsInModuleWithImports = (
   const shadowedModuleNames = new Set(moduleNames);
   const shadowedImportedNames = new Map(importedNames);
   for (const param of params) {
-    shadowedModuleNames.delete(param);
-    shadowedImportedNames.delete(param);
+    shadowedModuleNames.delete(param.name);
+    shadowedImportedNames.delete(param.name);
   }
 
   let result = desugarExprInModuleWithImports(
@@ -939,7 +962,13 @@ const desugarAbsInModuleWithImports = (
     shadowedImportedNames,
   );
   for (let i = params.length - 1; i >= 0; i--) {
-    result = C.cabs({ id: -1, original: params[i]! }, result, i === 0 ? span : undefined);
+    const param = params[i]!;
+    result = C.cabs(
+      { id: -1, original: param.name },
+      result,
+      i === 0 ? span : undefined,
+      param.span,
+    );
   }
   return result;
 };
@@ -1133,6 +1162,7 @@ const desugarDeclInModuleWithImports = (
         decl.constructors.map((c) => ({
           name: `${moduleName}.${c.name}`,
           fields: c.fields.map(desugarType),
+          span: c.span,
         })),
         decl.span,
       );