@formspec/build 0.1.0-alpha.54 → 0.1.0-alpha.55

package/dist/internals.js

@@ -828,6 +828,7 @@ import {
   isBuiltinConstraintName
 } from "@formspec/core/internals";
 import "@formspec/core/internals";
+import { noopLogger } from "@formspec/core";
 
 // src/extensions/resolve-custom-type.ts
 import * as ts2 from "typescript";
@@ -955,6 +956,15 @@ function isIntegerBrandedType(type) {
 }
 
 // src/analyzer/tsdoc-parser.ts
+import {
+  getBuildLogger,
+  getBroadeningLogger,
+  getSyntheticLogger,
+  describeTypeKind,
+  elapsedMicros,
+  nowMicros,
+  logTagApplication
+} from "@formspec/analysis/internal";
 function sharedTagValueOptions(options) {
   return {
     ...options?.extensionRegistry !== void 0 ? { registry: options.extensionRegistry } : {},
@@ -1361,56 +1371,82 @@ function buildCompilerBackedConstraintDiagnostics(node, sourceFile, tagName, par
   if (definition === null) {
     return [];
   }
+  const nonNullPlacement = placement;
+  const log = getBuildLogger();
+  const broadeningLog = getBroadeningLogger();
+  const syntheticLog = getSyntheticLogger();
+  const logsEnabled = log !== noopLogger || broadeningLog !== noopLogger;
+  const syntheticTraceEnabled = syntheticLog !== noopLogger;
+  const logStart = logsEnabled ? nowMicros() : 0;
+  const subjectTypeKind = logsEnabled ? describeTypeKind(subjectType, checker) : "";
+  function emit(outcome, result2) {
+    if (!logsEnabled) {
+      return result2;
+    }
+    const entry = {
+      consumer: "build",
+      tag: tagName,
+      placement: nonNullPlacement,
+      subjectTypeKind,
+      roleOutcome: outcome,
+      elapsedMicros: elapsedMicros(logStart)
+    };
+    logTagApplication(log, entry);
+    if (outcome === "bypass" || outcome === "D1" || outcome === "D2") {
+      logTagApplication(broadeningLog, entry);
+    }
+    return result2;
+  }
   if (!definition.placements.includes(placement)) {
-    return [
+    return emit("A-reject", [
       makeDiagnostic(
         "INVALID_TAG_PLACEMENT",
         `Tag "@${tagName}" is not allowed on ${placementLabel(placement)}.`,
         provenance
       )
-    ];
+    ]);
   }
   const target = parsedTag?.target ?? null;
   let evaluatedType = subjectType;
   let targetLabel = node.getText(sourceFile);
   if (target !== null) {
     if (target.kind !== "path") {
-      return [
+      return emit("B-reject", [
         makeDiagnostic(
           "UNSUPPORTED_TARGETING_SYNTAX",
           `Tag "@${tagName}" does not support ${target.kind} targeting syntax.`,
           provenance
         )
-      ];
+      ]);
     }
     if (!target.valid || target.path === null) {
-      return [
+      return emit("B-reject", [
         makeDiagnostic(
           "UNSUPPORTED_TARGETING_SYNTAX",
           `Tag "@${tagName}" has invalid path targeting syntax.`,
           provenance
         )
-      ];
+      ]);
     }
     const resolution = resolvePathTargetType(subjectType, checker, target.path.segments);
     if (resolution.kind === "missing-property") {
-      return [
+      return emit("B-reject", [
         makeDiagnostic(
           "UNKNOWN_PATH_TARGET",
           `Target "${target.rawText}": path-targeted constraint "${tagName}" references unknown path segment "${resolution.segment}"`,
           provenance
         )
-      ];
+      ]);
     }
     if (resolution.kind === "unresolvable") {
       const actualType = checker.typeToString(resolution.type, node, SYNTHETIC_TYPE_FORMAT_FLAGS);
-      return [
+      return emit("B-reject", [
         makeDiagnostic(
           "TYPE_MISMATCH",
           `Target "${target.rawText}": path-targeted constraint "${tagName}" is invalid because type "${actualType}" cannot be traversed`,
           provenance
         )
-      ];
+      ]);
     }
     evaluatedType = resolution.type;
     targetLabel = target.rawText;
@@ -1439,13 +1475,13 @@ function buildCompilerBackedConstraintDiagnostics(node, sourceFile, tagName, par
         tagName,
         parsedTag?.argumentText
       ) : null;
-      return [
+      return emit("B-reject", [
         makeDiagnostic(
           "TYPE_MISMATCH",
           hint === null ? baseMessage : `${baseMessage}. ${hint}`,
           provenance
         )
-      ];
+      ]);
     }
   }
   const argumentExpression = renderSyntheticArgumentExpression(
@@ -1453,14 +1489,23 @@ function buildCompilerBackedConstraintDiagnostics(node, sourceFile, tagName, par
     parsedTag?.argumentText ?? ""
   );
   if (definition.requiresArgument && argumentExpression === null) {
-    return [];
+    return emit("A-pass", []);
   }
   if (hasBroadening) {
-    return [];
+    return emit("bypass", []);
   }
   const subjectTypeText = checker.typeToString(subjectType, node, SYNTHETIC_TYPE_FORMAT_FLAGS);
   const hostType = options?.hostType ?? subjectType;
   const hostTypeText = checker.typeToString(hostType, node, SYNTHETIC_TYPE_FORMAT_FLAGS);
+  if (syntheticTraceEnabled) {
+    syntheticLog.trace("invoking synthetic checker", {
+      consumer: "build",
+      tag: tagName,
+      placement,
+      subjectTypeKind,
+      subjectTypeText
+    });
+  }
   const result = checkSyntheticTagApplication({
     tagName,
     placement,
@@ -1487,26 +1532,26 @@ function buildCompilerBackedConstraintDiagnostics(node, sourceFile, tagName, par
     } : {}
   });
   if (result.diagnostics.length === 0) {
-    return [];
+    return emit("C-pass", []);
   }
   const setupDiagnostic = result.diagnostics.find((diagnostic) => diagnostic.kind !== "typescript");
   if (setupDiagnostic !== void 0) {
-    return [
+    return emit("C-reject", [
       makeDiagnostic(
         setupDiagnostic.kind === "unsupported-custom-type-override" ? "UNSUPPORTED_CUSTOM_TYPE_OVERRIDE" : "SYNTHETIC_SETUP_FAILURE",
         setupDiagnostic.message,
         provenance
       )
-    ];
+    ]);
   }
   const expectedLabel = definition.valueKind === null ? "compatible argument" : capabilityLabel(definition.valueKind);
-  return [
+  return emit("C-reject", [
     makeDiagnostic(
       "TYPE_MISMATCH",
       `Tag "@${tagName}" received an invalid argument for ${expectedLabel}.`,
       provenance
     )
-  ];
+  ]);
 }
 var parseResultCache = /* @__PURE__ */ new Map();
 function getExtensionTagNames(options) {
@@ -2666,6 +2711,22 @@ function extractReferenceTypeArguments(type, checker, file, typeRegistry, visiti
   }
   return referenceTypeNode.typeArguments.map((argumentNode) => {
     const argumentType = checker.getTypeFromTypeNode(argumentNode);
+    const baseSymbol = argumentType.aliasSymbol ?? argumentType.getSymbol();
+    const argumentSymbol = baseSymbol !== void 0 && baseSymbol.flags & ts6.SymbolFlags.Alias ? checker.getAliasedSymbol(baseSymbol) : baseSymbol;
+    const argumentDecl = argumentSymbol?.declarations?.[0];
+    if (argumentDecl !== void 0 && argumentDecl.getSourceFile().fileName !== file) {
+      const argumentName = argumentSymbol?.getName() ?? baseSymbol?.getName();
+      if (argumentName !== void 0) {
+        return {
+          tsType: argumentType,
+          typeNode: {
+            kind: "reference",
+            name: argumentName,
+            typeArguments: []
+          }
+        };
+      }
+    }
     return {
       tsType: argumentType,
       typeNode: resolveTypeNode(
@@ -2932,22 +2993,10 @@ function resolveTypeNode(type, checker, file, typeRegistry, visiting, sourceNode
     sourceNode
   );
   if (customTypeLookup !== null) {
-    const typeId = customTypeIdFromLookup(customTypeLookup);
-    let payload = null;
-    if (customTypeLookup.registration.extractPayload !== void 0) {
-      try {
-        payload = customTypeLookup.registration.extractPayload(type, checker) ?? null;
-      } catch (cause) {
-        throw new Error(
-          `extractPayload for custom type "${customTypeLookup.registration.typeName}" in extension "${customTypeLookup.extensionId}" threw`,
-          { cause }
-        );
-      }
-    }
     return {
       kind: "custom",
-      typeId,
-      payload
+      typeId: customTypeIdFromLookup(customTypeLookup),
+      payload: null
     };
   }
   const primitiveAlias = tryResolveNamedPrimitiveAlias(
@@ -3131,6 +3180,21 @@ function getReferencedTypeAliasDeclaration(sourceNode, checker) {
   }
   return getTypeAliasDeclarationFromTypeReference(typeNode, checker);
 }
+function resolveNamedTypeWithSourceRecovery(type, sourceNode, checker) {
+  const typeName = getNamedTypeName(type);
+  const namedDecl = getNamedTypeDeclaration(type);
+  if (typeName !== null && namedDecl !== void 0) {
+    return { typeName, namedDecl };
+  }
+  if (sourceNode === void 0) {
+    return null;
+  }
+  const refAliasDecl = getReferencedTypeAliasDeclaration(sourceNode, checker);
+  if (refAliasDecl === void 0) {
+    return null;
+  }
+  return { typeName: refAliasDecl.name.text, namedDecl: refAliasDecl };
+}
 function shouldEmitPrimitiveAliasDefinition(typeNode, checker) {
   if (!ts6.isTypeReferenceNode(typeNode)) {
     return false;
@@ -3189,8 +3253,23 @@ function resolveAliasedPrimitiveTarget(type, checker, file, typeRegistry, visiti
   );
 }
 function resolveUnionType(type, checker, file, typeRegistry, visiting, sourceNode, metadataPolicy = createAnalyzerMetadataPolicy(void 0), extensionRegistry, diagnostics) {
-  const typeName = getNamedTypeName(type);
-  const namedDecl = getNamedTypeDeclaration(type);
+  const recovered = resolveNamedTypeWithSourceRecovery(type, sourceNode, checker);
+  let typeName = null;
+  let namedDecl;
+  if (recovered !== null) {
+    const recoveredAliasDecl = ts6.isTypeAliasDeclaration(recovered.namedDecl) ? recovered.namedDecl : void 0;
+    if (recoveredAliasDecl !== void 0) {
+      const aliasUnderlyingType = checker.getTypeFromTypeNode(recoveredAliasDecl.type);
+      const isNonGeneric = recoveredAliasDecl.typeParameters === void 0 || recoveredAliasDecl.typeParameters.length === 0;
+      if (isNonGeneric && (aliasUnderlyingType.isUnion() || isObjectType(aliasUnderlyingType))) {
+        typeName = recovered.typeName;
+        namedDecl = recovered.namedDecl;
+      }
+    } else {
+      typeName = recovered.typeName;
+      namedDecl = recovered.namedDecl;
+    }
+  }
   if (typeName && typeName in typeRegistry) {
     return { kind: "reference", name: typeName, typeArguments: [] };
   }
@@ -3222,6 +3301,10 @@ function resolveUnionType(type, checker, file, typeRegistry, visiting, sourceNod
     if (!typeName) {
       return result;
     }
+    const existing = typeRegistry[typeName];
+    if (existing !== void 0 && existing.type !== RESOLVING_TYPE_PLACEHOLDER) {
+      return { kind: "reference", name: typeName, typeArguments: [] };
+    }
     const annotations = namedDecl ? extractJSDocAnnotationNodes(namedDecl, file, makeParseOptions(extensionRegistry)) : void 0;
     const metadata = namedDecl !== void 0 ? resolveNodeMetadata(
       metadataPolicy,
@@ -4553,10 +4636,11 @@ function generatePrimitiveType(type) {
 function generateEnumType(type, ctx) {
   if (ctx.enumSerialization === "oneOf") {
     return {
-      oneOf: type.members.map((m) => ({
-        const: m.value,
-        title: m.displayName ?? String(m.value)
-      }))
+      oneOf: type.members.map((m) => {
+        const stringValue = String(m.value);
+        const title = m.displayName !== void 0 && m.displayName !== stringValue ? m.displayName : void 0;
+        return title !== void 0 ? { const: m.value, title } : { const: m.value };
+      })
     };
   }
   const schema = { enum: type.members.map((m) => m.value) };
@@ -5051,7 +5135,8 @@ import {
 } from "@formspec/core/internals";
 import {
   getTagDefinition as getTagDefinition2,
-  normalizeFormSpecTagName as normalizeFormSpecTagName2
+  normalizeFormSpecTagName as normalizeFormSpecTagName2,
+  getSyntheticLogger as getSyntheticLogger2
 } from "@formspec/analysis/internal";
 var BUILTIN_METADATA_TAGS = /* @__PURE__ */ new Set(["apiName", "displayName"]);
 function buildConstraintTagSources(extensions) {
@@ -5065,6 +5150,11 @@ function buildConstraintTagSources(extensions) {
   }));
 }
 function createExtensionRegistry(extensions) {
+  const registryLog = getSyntheticLogger2();
+  registryLog.debug("createExtensionRegistry: constructing", {
+    extensionCount: extensions.length,
+    extensionIds: extensions.map((e) => e.extensionId)
+  });
   const reservedTagSources = buildConstraintTagSources(extensions);
   let symbolMap = /* @__PURE__ */ new Map();
   const typeMap = /* @__PURE__ */ new Map();
@@ -5196,6 +5286,14 @@ function createExtensionRegistry(extensions) {
       }
     }
   }
+  registryLog.debug("createExtensionRegistry: complete", {
+    typeCount: typeMap.size,
+    constraintCount: constraintMap.size,
+    constraintTagCount: constraintTagMap.size,
+    broadeningCount: builtinBroadeningMap.size,
+    annotationCount: annotationMap.size,
+    metadataSlotCount: metadataSlotMap.size
+  });
   return {
     extensions,
     findType: (typeId) => typeMap.get(typeId),