@typespec/http-server-csharp 0.58.0-alpha.9-dev.0 → 0.58.0-dev.0

package/dist/src/lib/utils.js

@@ -1,10 +1,14 @@
-import { NoTarget, getFriendlyName, isNullType, isNumericType, isTemplateInstance, isUnknownType, isVoidType, } from "@typespec/compiler";
-import { StringBuilder } from "@typespec/compiler/emitter-framework";
-import { Visibility, createMetadataInfo, isBody, isBodyRoot, isMetadata, isStatusCode, } from "@typespec/http";
+import { StringBuilder, code, } from "@typespec/asset-emitter";
+import { NoTarget, getFriendlyName, getMinValue, isArrayModelType, isErrorModel, isNullType, isNumericType, isTemplateInstance, isUnknownType, isVoidType, resolveCompilerOptions, resolvePath, serializeValueAsJson, } from "@typespec/compiler";
+import { $ } from "@typespec/compiler/typekit";
+import { Visibility, createMetadataInfo, getHeaderFieldName, isBody, isBodyRoot, isHeader, isMetadata, isPathParam, isQueryParam, isStatusCode, } from "@typespec/http";
+import { getUniqueItems } from "@typespec/json-schema";
 import { camelCase, pascalCase } from "change-case";
+import { createServer } from "net";
 import { getAttributes } from "./attributes.js";
-import { BooleanValue, CSharpType, NameCasingType, NullValue, NumericValue, StringValue, } from "./interfaces.js";
-import { reportDiagnostic } from "./lib.js";
+import { BooleanValue, CSharpCollectionType, CSharpType, CollectionType, NameCasingType, NullValue, NumericValue, StringValue, checkOrAddNamespaceToScope, } from "./interfaces.js";
+import { CSharpServiceOptions, reportDiagnostic } from "./lib.js";
+import { getDoubleType, getEnumType } from "./type-helpers.js";
 const _scalars = new Map();
 export function getCSharpTypeForScalar(program, scalar) {
     if (_scalars.has(scalar))
@@ -21,7 +25,7 @@ export function getCSharpTypeForScalar(program, scalar) {
         target: scalar,
     });
     const result = new CSharpType({
-        name: "Object",
+        name: "object",
         namespace: "System",
         isBuiltIn: true,
         isValueType: false,
@@ -31,9 +35,17 @@ export function getCSharpTypeForScalar(program, scalar) {
 }
 export const UnknownType = new CSharpType({
     name: "JsonNode",
-    namespace: "System.Text.Json",
+    namespace: "System.Text.Json.Nodes",
+    isValueType: false,
+    isBuiltIn: false,
+    isClass: true,
+});
+export const RecordType = new CSharpType({
+    name: "JsonObject",
+    namespace: "System.Text.Json.Nodes",
+    isBuiltIn: false,
     isValueType: false,
-    isBuiltIn: true,
+    isClass: true,
 });
 export function getCSharpType(program, type, namespace) {
     const known = getKnownType(program, type);
@@ -54,8 +66,6 @@ export function getCSharpType(program, type, namespace) {
                 return { type: standardScalars.get("numeric"), value: new NumericValue(enumValue) };
         case "Intrinsic":
             return getCSharpTypeForIntrinsic(program, type);
-        case "Object":
-            return { type: UnknownType };
         case "ModelProperty":
             return getCSharpType(program, type.type, namespace);
         case "Scalar":
@@ -79,18 +89,21 @@ export function getCSharpType(program, type, namespace) {
             return {
                 type: new CSharpType({
                     name: ensureCSharpIdentifier(program, type, type.name, NameCasingType.Class),
-                    namespace: namespace || "Models",
+                    namespace: `${namespace}`,
                     isBuiltIn: false,
                     isValueType: false,
+                    isClass: true,
                 }),
             };
         case "Enum":
+            if (getEnumType(type) === "double")
+                return { type: getDoubleType() };
             return {
                 type: new CSharpType({
                     name: ensureCSharpIdentifier(program, type, type.name, NameCasingType.Class),
-                    namespace: `${namespace}.Models`,
+                    namespace: `${namespace}`,
                     isBuiltIn: false,
-                    isValueType: false,
+                    isValueType: true,
                 }),
             };
         case "Model":
@@ -99,15 +112,32 @@ export function getCSharpType(program, type, namespace) {
                 if (resolvedItem === undefined)
                     return undefined;
                 const { type: itemType, value: _ } = resolvedItem;
+                const uniqueItems = getUniqueItems(program, type);
+                const isByte = ["byte", "SByte"].includes(itemType.name);
+                const collectionType = CSharpServiceOptions.getInstance().collectionType;
+                const returnTypeCollection = uniqueItems
+                    ? CollectionType.ISet
+                    : isByte
+                        ? CollectionType.Array
+                        : collectionType;
+                const returnType = returnTypeCollection === CollectionType.Array
+                    ? `${itemType.name}[]`
+                    : `${returnTypeCollection}<${itemType.name}>`;
                 return {
-                    type: new CSharpType({
-                        name: `${itemType.name}[]`,
+                    type: new CSharpCollectionType({
+                        name: returnType,
                         namespace: itemType.namespace,
                         isBuiltIn: itemType.isBuiltIn,
                         isValueType: false,
-                    }),
+                        isClass: itemType.isClass,
+                        isCollection: true,
+                    }, returnTypeCollection, itemType.name),
                 };
             }
+            if (isRecord(type))
+                return {
+                    type: RecordType,
+                };
             let name = type.name;
             if (isTemplateInstance(type)) {
                 name = getModelInstantiationName(program, type, name);
@@ -115,15 +145,38 @@ export function getCSharpType(program, type, namespace) {
             return {
                 type: new CSharpType({
                     name: ensureCSharpIdentifier(program, type, name, NameCasingType.Class),
-                    namespace: `${namespace}.Models`,
+                    namespace: `${namespace}`,
                     isBuiltIn: false,
                     isValueType: false,
+                    isClass: true,
                 }),
             };
         default:
             return undefined;
     }
 }
+export function resolveReferenceFromScopes(targetDeclaration, declarationScopes, referenceScopes) {
+    function getSourceFile(scopes) {
+        for (const scope of scopes) {
+            if (scope.kind === "sourceFile") {
+                return { scope: scope, file: scope.sourceFile };
+            }
+        }
+        return undefined;
+    }
+    const decl = getSourceFile(declarationScopes);
+    const ref = getSourceFile(referenceScopes);
+    if (targetDeclaration.name && decl) {
+        const declNs = decl.file.meta["ResolvedNamespace"];
+        if (!ref)
+            return declNs ? `${declNs}.${targetDeclaration.name} ` : undefined;
+        if (checkOrAddNamespaceToScope(declNs, ref.scope)) {
+            return targetDeclaration.name;
+        }
+        return declNs ? `${declNs}.${targetDeclaration.name} ` : undefined;
+    }
+    return undefined;
+}
 export function coalesceTypes(program, types, namespace) {
     const visited = new Map();
     let candidateType = undefined;
@@ -356,27 +409,33 @@ export function isValueType(program, type) {
 export function formatComment(text, lineLength = 76, lineEnd = "\n") {
     function getNextLine(target) {
         for (let i = lineLength - 1; i > 0; i--) {
-            if ([" ", ".", "?", ",", ";"].includes(target.charAt(i))) {
-                return `/// ${text.substring(0, i).replaceAll("\n", " ")}`;
+            if ([" ", ";"].includes(target.charAt(i))) {
+                return `${target.substring(0, i)}`;
+            }
+        }
+        for (let i = lineLength - 1; i < target.length; i++) {
+            if ([" ", ";"].includes(target.charAt(i))) {
+                return `${target.substring(0, i)}`;
             }
         }
-        return `/// ${text.substring(0, lineLength)}`;
+        return `${target.substring(0, lineLength)}`;
     }
-    let remaining = text;
+    let remaining = text.replaceAll("\n", " ");
     const lines = [];
     while (remaining.length > lineLength) {
         const currentLine = getNextLine(remaining);
         remaining =
             remaining.length > currentLine.length ? remaining.substring(currentLine.length + 1) : "";
-        lines.push(currentLine);
+        lines.push(`/// ${currentLine}`);
     }
     if (remaining.length > 0)
         lines.push(`/// ${remaining}`);
     return `///<summary>${lineEnd}${lines.join(lineEnd)}${lineEnd}///</summary>`;
 }
-export function getCSharpIdentifier(name, context = NameCasingType.Class) {
+export function getCSharpIdentifier(name, context = NameCasingType.Class, checkReserved = true) {
     if (name === undefined)
         return "Placeholder";
+    name = replaceCSharpReservedWord(name, context);
     switch (context) {
         case NameCasingType.Namespace:
             const parts = [];
@@ -393,6 +452,7 @@ export function getCSharpIdentifier(name, context = NameCasingType.Class) {
 }
 export function ensureCSharpIdentifier(program, target, name, context = NameCasingType.Class) {
     let location = "";
+    let includeDot = false;
     switch (target.kind) {
         case "Enum":
             location = `enum ${target.name}`;
@@ -426,11 +486,9 @@ export function ensureCSharpIdentifier(program, target, name, context = NameCasi
         case "Namespace":
             location = `namespace ${target.name}`;
             let invalid = false;
-            const nsName = new StringBuilder();
             for (const part of name.split(".")) {
                 if (!isValidCSharpIdentifier(part)) {
                     invalid = true;
-                    nsName.pushLiteralSegment(transformInvalidIdentifier(part));
                 }
             }
             if (invalid) {
@@ -439,9 +497,9 @@ export function ensureCSharpIdentifier(program, target, name, context = NameCasi
                     format: { identifier: name, location: location },
                     target: target.node ?? NoTarget,
                 });
-                return nsName.segments.join(".");
             }
-            return name;
+            includeDot = true;
+            break;
         case "Operation": {
             const parent = target.interface
                 ? `interface ${target.interface.name}`
@@ -453,15 +511,11 @@ export function ensureCSharpIdentifier(program, target, name, context = NameCasi
             location = `union ${target.name}`;
             break;
         case "UnionVariant": {
-            if (target.node !== undefined) {
-                const parent = program.checker.getTypeForNode(target.node.parent);
-                if (parent?.kind === "Union")
-                    location = `variant ${String(target.name)} in union ${parent?.name}`;
-            }
+            location = `variant ${String(target.name)} in union ${target.union.name}`;
             break;
         }
     }
-    if (!isValidCSharpIdentifier(name)) {
+    if (!isValidCSharpIdentifier(name, includeDot)) {
         reportDiagnostic(program, {
             code: "invalid-identifier",
             format: { identifier: name, location: location },
@@ -474,6 +528,23 @@ export function ensureCSharpIdentifier(program, target, name, context = NameCasi
 export function getModelAttributes(program, entity, cSharpName) {
     return getAttributes(program, entity, cSharpName);
 }
+export function getModelDeclarationName(program, model, defaultSuffix) {
+    if (model.name !== null && model.name.length > 0) {
+        return ensureCSharpIdentifier(program, model, model.name, NameCasingType.Class);
+    }
+    if (model.sourceModel && model.sourceModel.name && model.sourceModel.name.length > 0) {
+        return ensureCSharpIdentifier(program, model, `${model.sourceModel.name}${defaultSuffix}`, NameCasingType.Class);
+    }
+    if (model.sourceModels.length > 0) {
+        const sourceNames = model.sourceModels
+            .filter((m) => m.model.name !== undefined && m.model.name.length > 0)
+            .flatMap((m) => ensureCSharpIdentifier(program, model, m.model.name, NameCasingType.Class));
+        if (sourceNames.length > 0) {
+            return `${sourceNames.join()}${defaultSuffix}`;
+        }
+    }
+    return `Model${defaultSuffix}`;
+}
 export function getModelInstantiationName(program, model, name) {
     const friendlyName = getFriendlyName(program, model);
     if (friendlyName && friendlyName.length > 0)
@@ -563,12 +634,16 @@ export class HttpMetadata {
         });
         switch (responseType.kind) {
             case "Model":
+                if (responseType.indexer && responseType.indexer.key.name !== "string")
+                    return responseType;
+                if (isRecord(responseType))
+                    return responseType;
                 const bodyProp = new ModelInfo().filterAllProperties(program, responseType, (p) => isBody(program, p) || isBodyRoot(program, p));
                 if (bodyProp !== undefined)
                     return metaInfo.getEffectivePayloadType(bodyProp.type, Visibility.Read);
                 const anyProp = new ModelInfo().filterAllProperties(program, responseType, (p) => !isMetadata(program, p) && !isStatusCode(program, p));
                 if (anyProp === undefined)
-                    return program.checker.voidType;
+                    return $(program).intrinsic.void;
                 if (responseType.name === "") {
                     return metaInfo.getEffectivePayloadType(responseType, Visibility.Read);
                 }
@@ -615,8 +690,148 @@ export async function ensureCleanDirectory(program, targetPath) {
     catch { }
     await program.host.mkdirp(targetPath);
 }
-export function isValidCSharpIdentifier(identifier) {
-    return identifier?.match(/^[A-Za-z_][\w]*$/) !== null;
+export function isValidCSharpIdentifier(identifier, isNamespace = false) {
+    if (!isNamespace)
+        return identifier?.match(/^[A-Za-z_][\w]*$/) !== null;
+    return identifier?.match(/^[A-Za-z_][\w.]*$/) !== null;
+}
+export function replaceCSharpReservedWord(identifier, context) {
+    function generateReplacement(input) {
+        return [input, `${pascalCase(input)}Name`];
+    }
+    const contextualWords = [
+        "add",
+        "allows",
+        "alias",
+        "and",
+        "ascending",
+        "args",
+        "async",
+        "await",
+        "by",
+        "descending",
+        "dynamic",
+        "equals",
+        "field",
+        "file",
+        "from",
+        "get",
+        "global",
+        "group",
+        "init",
+        "into",
+        "join",
+        "let",
+        "managed",
+        "nameof",
+        "nint",
+        "not",
+        "notnull",
+        "nuint",
+        "on",
+        "or",
+        "orderby",
+        "partial",
+        "record",
+        "remove",
+        "required",
+        "scoped",
+        "select",
+        "set",
+        "unmanaged",
+        "value",
+        "var",
+        "when",
+        "where",
+        "with",
+        "yield",
+    ];
+    const reservedWords = [
+        "abstract",
+        "as",
+        "base",
+        "bool",
+        "boolean",
+        "break",
+        "byte",
+        "case",
+        "catch",
+        "char",
+        "checked",
+        "class",
+        "const",
+        "continue",
+        "decimal",
+        "default",
+        "do",
+        "double",
+        "else",
+        "enum",
+        "event",
+        "explicit",
+        "extern",
+        "false",
+        "finally",
+        "fixed",
+        "float",
+        "for",
+        "foreach",
+        "goto",
+        "if",
+        "implicit",
+        "in",
+        "int",
+        "interface",
+        "internal",
+        "is",
+        "lock",
+        "long",
+        "namespace",
+        "new",
+        "null",
+        "object",
+        "operator",
+        "out",
+        "override",
+        "params",
+        "private",
+        "protected",
+        "public",
+        "readonly",
+        "ref",
+        "return",
+        "sbyte",
+        "sealed",
+        "short",
+        "sizeof",
+        "stackalloc",
+        "static",
+        "string",
+        "struct",
+        "switch",
+        "this",
+        "throw",
+        "true",
+        "try",
+        "type",
+        "typeof",
+        "uint",
+        "ulong",
+        "unchecked",
+        "unsafe",
+        "ushort",
+        "using",
+        "virtual",
+        "void",
+        "volatile",
+        "while",
+    ];
+    const reserved = new Map(reservedWords.concat(contextualWords).map((w) => generateReplacement(w)));
+    const check = reserved.get(identifier.toLowerCase());
+    if (check !== undefined) {
+        return getCSharpIdentifier(check, context, false);
+    }
+    return identifier;
 }
 export function getValidChar(target, position) {
     if (position === 0) {
@@ -642,4 +857,724 @@ export function getCSharpStatusCode(entry) {
             return undefined;
     }
 }
+/**
+ * Returns the full return statement for a controller action based on the HTTP status code.
+ * Maps well-known status codes to their idiomatic ASP.NET Core ControllerBase methods,
+ * and falls back to `StatusCode(code, ...)` for all other numeric codes.
+ */
+export function getControllerReturnStatement(status, hasValue) {
+    if (typeof status === "number") {
+        switch (status) {
+            case 200:
+                return hasValue ? "return Ok(result);" : "return Ok();";
+            case 202:
+                return hasValue ? "return Accepted(result);" : "return Accepted();";
+            case 204:
+                return "return NoContent();";
+            default:
+                return hasValue ? `return StatusCode(${status}, result);` : `return StatusCode(${status});`;
+        }
+    }
+    // Fallback for ranges and "*"
+    return hasValue ? "return Ok(result);" : "return Ok();";
+}
+export function isEmptyResponseModel(program, model) {
+    if (model.kind !== "Model")
+        return false;
+    if (model.properties.size === 0)
+        return true;
+    return (model.properties.size === 1 &&
+        isStatusCode(program, [...model.properties.values()][0]) &&
+        !isErrorModel(program, model));
+}
+export function isContentTypeHeader(program, parameter) {
+    return (isHeader(program, parameter) &&
+        (parameter.name === "contentType" || getHeaderFieldName(program, parameter) === "Content-type"));
+}
+export function isValidParameter(program, parameter) {
+    return (!isContentTypeHeader(program, parameter) &&
+        (parameter.type.kind !== "Intrinsic" || parameter.type.name !== "never") &&
+        parameter.model?.name === "");
+}
+/** Determine whether the given parameter is http metadata */
+export function isHttpMetadata(program, property) {
+    return (isPathParam(program, property) || isHeader(program, property) || isQueryParam(program, property));
+}
+export function getBusinessLogicCallParameters(parameters) {
+    const builder = new StringBuilder();
+    const blParameters = parameters.filter((p) => p.operationKind === "BusinessLogic" || p.operationKind === "All");
+    let i = 0;
+    for (const param of blParameters) {
+        builder.push(code `${getBusinessLogicCallParameter(param)}${++i < blParameters.length ? ", " : ""}`);
+    }
+    return builder.reduce();
+}
+export function getBusinessLogicDeclParameters(parameters) {
+    const builder = new StringBuilder();
+    const blParameters = parameters.filter((p) => p.operationKind === "BusinessLogic" || p.operationKind === "All");
+    let i = 0;
+    for (const param of blParameters) {
+        builder.push(code `${getBusinessLogicSignatureParameter(param)}${++i < blParameters.length ? ", " : ""}`);
+    }
+    return builder.reduce();
+}
+export function getHttpDeclParameters(parameters) {
+    const builder = new StringBuilder();
+    const blParameters = parameters.filter((p) => p.operationKind === "Http" || p.operationKind === "All");
+    let i = 0;
+    for (const param of blParameters) {
+        builder.push(code `${getHttpSignatureParameter(param)}${++i < blParameters.length ? ", " : ""}`);
+    }
+    return builder.reduce();
+}
+export function getBusinessLogicCallParameter(param) {
+    const builder = new StringBuilder();
+    builder.push(code `${param.callName}`);
+    return builder.reduce();
+}
+export function getBusinessLogicSignatureParameter(param) {
+    const builder = new StringBuilder();
+    builder.push(code `${param.typeName}${param.optional || param.nullable ? "? " : " "}${param.name}`);
+    return builder.reduce();
+}
+export function getHttpSignatureParameter(param) {
+    const builder = new StringBuilder();
+    builder.push(code `${getHttpParameterDecorator(param)}${getBusinessLogicSignatureParameter(param)}${param.defaultValue === undefined ? "" : code ` = ${typeof param.defaultValue === "boolean" ? code `${param.defaultValue.toString()}` : code `${param.defaultValue}`}`}`);
+    return builder.reduce();
+}
+export function getHttpParameterDecorator(parameter) {
+    switch (parameter.httpParameterKind) {
+        case "query":
+            return code `[FromQuery${parameter.httpParameterName ? code `(Name="${parameter.httpParameterName}")` : ""}] `;
+        case "header":
+            return code `[FromHeader${parameter.httpParameterName ? code `(Name="${parameter.httpParameterName}")` : ""}] `;
+        default:
+            return "";
+    }
+}
+export function getParameterKind(parameter) {
+    switch (parameter.type) {
+        case "path":
+            return "path";
+        case "cookie":
+        case "header":
+            return "header";
+        case "query":
+            return "query";
+    }
+}
+export function canHaveDefault(program, type) {
+    switch (type.kind) {
+        case "Boolean":
+        case "EnumMember":
+        case "Enum":
+        case "Number":
+        case "String":
+        case "Scalar":
+        case "StringTemplate":
+            return true;
+        case "ModelProperty":
+            return canHaveDefault(program, type.type);
+        default:
+            return false;
+    }
+}
+export class CSharpOperationHelpers {
+    constructor(inEmitter) {
+        this.emitter = inEmitter;
+        this.#anonymousModels = new Map();
+        this.#opCache = new Map();
+    }
+    emitter;
+    #anonymousModels;
+    #opCache;
+    getResponse(program, operation) {
+        return new CSharpType({
+            name: "void",
+            namespace: "System",
+            isBuiltIn: true,
+            isValueType: true,
+        });
+    }
+    getParameters(program, operation) {
+        function safeConcat(...names) {
+            return names
+                .filter((n) => n !== undefined && n !== null && n.length > 0)
+                .flatMap((s) => getCSharpIdentifier(s, NameCasingType.Class))
+                .join();
+        }
+        const cached = this.#opCache.get(operation.operation);
+        if (cached)
+            return cached;
+        const bodyParam = operation.parameters.body;
+        const isExplicitBodyParam = bodyParam?.property !== undefined;
+        const result = [];
+        if (!cached && operation.verb === "get" && operation.parameters.body !== undefined) {
+            reportDiagnostic(program, {
+                code: "get-request-body",
+                target: operation.operation,
+                format: {},
+            });
+            this.#opCache.set(operation.operation, result);
+            return result;
+        }
+        const validParams = operation.parameters.parameters.filter((p) => isValidParameter(program, p.param));
+        const requiredParams = validParams.filter((p) => p.type === "path" || (!p.param.optional && p.param.defaultValue === undefined));
+        const optionalParams = validParams.filter((p) => p.type !== "path" && (p.param.optional || p.param.defaultValue !== undefined));
+        for (const parameter of requiredParams) {
+            let { typeReference: paramType, defaultValue: paramValue } = this.getTypeInfo(program, parameter.param.type);
+            // cSharp does not allow array defaults in operation parameters
+            if (!canHaveDefault(program, parameter.param)) {
+                paramValue = undefined;
+            }
+            const paramName = ensureCSharpIdentifier(program, parameter.param, parameter.param.name, NameCasingType.Parameter);
+            result.push({
+                isExplicitBody: false,
+                name: paramName,
+                callName: paramName,
+                optional: false,
+                typeName: paramType,
+                defaultValue: paramValue,
+                httpParameterKind: getParameterKind(parameter),
+                httpParameterName: parameter.name,
+                nullable: false,
+                operationKind: "All",
+            });
+        }
+        const overrideParameters = getExplicitBodyParameters(program, operation);
+        if (overrideParameters !== undefined) {
+            for (const overrideParam of overrideParameters) {
+                result.push(overrideParam);
+            }
+        }
+        else if (bodyParam !== undefined && isExplicitBodyParam) {
+            let { typeReference: bodyType, defaultValue: bodyValue, nullableType: isNullable, } = this.getTypeInfo(program, bodyParam.type);
+            if (!canHaveDefault(program, bodyParam.type)) {
+                bodyValue = undefined;
+            }
+            result.push({
+                isExplicitBody: true,
+                httpParameterKind: "body",
+                name: "body",
+                callName: "body",
+                typeName: bodyType,
+                nullable: isNullable,
+                defaultValue: bodyValue,
+                optional: bodyParam.property?.optional ?? false,
+                operationKind: "All",
+            });
+        }
+        else if (bodyParam !== undefined) {
+            switch (bodyParam.type.kind) {
+                case "Model":
+                    let tsBody = bodyParam.type;
+                    if (!bodyParam.type.name) {
+                        tsBody = program.checker.cloneType(bodyParam.type, {
+                            name: safeConcat(operation.operation.interface?.name, operation.operation.name, "Request"),
+                        });
+                    }
+                    const { typeReference: bodyType } = this.getTypeInfo(program, tsBody);
+                    const bodyName = ensureCSharpIdentifier(program, bodyParam.type, "body", NameCasingType.Parameter);
+                    result.push({
+                        isExplicitBody: false,
+                        httpParameterKind: "body",
+                        name: bodyName,
+                        callName: bodyName,
+                        typeName: bodyType,
+                        nullable: false,
+                        defaultValue: undefined,
+                        optional: false,
+                        operationKind: "Http",
+                    });
+                    for (const [propName, propDef] of bodyParam.type.properties) {
+                        let { typeReference: csType, defaultValue: csValue, nullableType: isNullable, } = this.getTypeInfo(program, propDef.type, propDef);
+                        // cSharp does not allow array defaults in operation parameters
+                        if (!canHaveDefault(program, propDef)) {
+                            csValue = undefined;
+                        }
+                        const paramName = ensureCSharpIdentifier(program, propDef, propName, NameCasingType.Parameter);
+                        const refName = ensureCSharpIdentifier(program, propDef, propName, NameCasingType.Property);
+                        result.push({
+                            isExplicitBody: false,
+                            httpParameterKind: "body",
+                            name: paramName,
+                            callName: `body.${refName}`,
+                            typeName: csType,
+                            nullable: isNullable,
+                            defaultValue: csValue,
+                            optional: propDef.optional,
+                            operationKind: "BusinessLogic",
+                        });
+                    }
+                    break;
+                case "ModelProperty":
+                    {
+                        let { typeReference: csType, defaultValue: csValue, nullableType: isNullable, } = this.getTypeInfo(program, bodyParam.type.type, bodyParam.type);
+                        if (!canHaveDefault(program, bodyParam.type)) {
+                            csValue = undefined;
+                        }
+                        const optName = ensureCSharpIdentifier(program, bodyParam.type.type, bodyParam.type.name, NameCasingType.Parameter);
+                        result.push({
+                            isExplicitBody: true,
+                            httpParameterKind: "body",
+                            name: optName,
+                            callName: optName,
+                            typeName: csType,
+                            nullable: isNullable,
+                            defaultValue: csValue,
+                            optional: bodyParam.type.optional,
+                            operationKind: "All",
+                        });
+                    }
+                    break;
+                default: {
+                    let { typeReference: csType, defaultValue: csValue, nullableType: isNullable, } = this.getTypeInfo(program, bodyParam.type);
+                    if (!canHaveDefault(program, bodyParam.type)) {
+                        csValue = undefined;
+                    }
+                    result.push({
+                        isExplicitBody: true,
+                        httpParameterKind: "body",
+                        name: "body",
+                        callName: "body",
+                        typeName: csType,
+                        nullable: isNullable,
+                        defaultValue: csValue,
+                        optional: false,
+                        operationKind: "All",
+                    });
+                }
+            }
+        }
+        for (const parameter of optionalParams) {
+            const { typeReference: paramType, defaultValue: paramValue, nullableType: isNullable, } = this.getTypeInfo(program, parameter.param.type, parameter.param);
+            const optName = ensureCSharpIdentifier(program, parameter.param, parameter.param.name, NameCasingType.Parameter);
+            result.push({
+                isExplicitBody: false,
+                name: optName,
+                callName: optName,
+                optional: true,
+                typeName: paramType,
+                defaultValue: paramValue,
+                httpParameterKind: getParameterKind(parameter),
+                httpParameterName: parameter.name,
+                nullable: isNullable,
+                operationKind: "All",
+            });
+        }
+        return result;
+    }
+    getDefaultValue(program, tsType, defaultValue) {
+        if (defaultValue === undefined)
+            return undefined;
+        switch (tsType.kind) {
+            case "Enum":
+                if (defaultValue.valueKind === "EnumValue") {
+                    const retVal = this.getTypeInfo(program, tsType);
+                    return `${retVal.typeReference}.${ensureCSharpIdentifier(program, defaultValue.value, defaultValue.value.name, NameCasingType.Property)}`;
+                }
+                return JSON.stringify(serializeValueAsJson(this.emitter.getProgram(), defaultValue, tsType));
+            case "Union":
+                const { typeReference: typeRef } = this.getUnionInfo(program, tsType);
+                if (defaultValue.valueKind === "StringValue" && isStringEnumType(program, tsType)) {
+                    const matches = [...tsType.variants].filter((v) => typeof v[0] === "string" &&
+                        v[1].type.kind === "String" &&
+                        v[1].type.value === defaultValue.value);
+                    if (matches.length === 1) {
+                        return `${typeRef}.${ensureCSharpIdentifier(program, matches[0][1], matches[0][0], NameCasingType.Property)}`;
+                    }
+                    return undefined;
+                }
+                if (defaultValue.valueKind === "StringValue") {
+                    return JSON.stringify(serializeValueAsJson(this.emitter.getProgram(), defaultValue, tsType));
+                }
+                return undefined;
+            default:
+                return JSON.stringify(serializeValueAsJson(this.emitter.getProgram(), defaultValue, tsType));
+        }
+    }
+    getTypeInfo(program, tsType, modelProperty) {
+        const myEmitter = this.emitter;
+        function extractStringValue(type, span) {
+            switch (type.kind) {
+                case "String":
+                    return type.value;
+                case "Boolean":
+                    return `${type.value}`;
+                case "Number":
+                    return type.valueAsString;
+                case "StringTemplateSpan":
+                    if (type.isInterpolated) {
+                        return extractStringValue(type.type, span);
+                    }
+                    else {
+                        return type.type.value;
+                    }
+                case "ModelProperty":
+                    return extractStringValue(type.type, span);
+                case "EnumMember":
+                    if (type.value === undefined)
+                        return type.name;
+                    if (typeof type.value === "string")
+                        return type.value;
+                    if (typeof type.value === "number")
+                        return `${type.value}`;
+            }
+            reportDiagnostic(myEmitter.getProgram(), {
+                code: "invalid-interpolation",
+                target: span,
+                format: {},
+            });
+            return "";
+        }
+        switch (tsType.kind) {
+            case "String":
+                return {
+                    typeReference: code `string`,
+                    defaultValue: `"${tsType.value}"`,
+                    nullableType: false,
+                };
+            case "StringTemplate":
+                const template = tsType;
+                if (template.stringValue !== undefined)
+                    return {
+                        typeReference: code `string`,
+                        defaultValue: `"${template.stringValue}"`,
+                        nullableType: false,
+                    };
+                const spanResults = [];
+                for (const span of template.spans) {
+                    spanResults.push(extractStringValue(span, span));
+                }
+                return {
+                    typeReference: code `string`,
+                    defaultValue: `"${spanResults.join("")}"`,
+                    nullableType: false,
+                };
+            case "Boolean":
+                return {
+                    typeReference: code `bool`,
+                    defaultValue: `${tsType.value === true ? true : false}`,
+                    nullableType: false,
+                };
+            case "Number":
+                const [type, value] = findNumericType(tsType);
+                return { typeReference: code `${type}`, defaultValue: `${value}`, nullableType: false };
+            case "Tuple":
+                const defaults = [];
+                const [csharpType, isObject] = coalesceTsTypes(program, tsType.values);
+                if (isObject)
+                    return { typeReference: "object[]", defaultValue: undefined, nullableType: false };
+                for (const value of tsType.values) {
+                    const { defaultValue: itemDefault } = this.getTypeInfo(program, value);
+                    defaults.push(itemDefault);
+                }
+                const collectionType = CSharpServiceOptions.getInstance().collectionType;
+                switch (collectionType) {
+                    case CollectionType.IEnumerable:
+                        return {
+                            typeReference: code `IEnumerable<${csharpType.getTypeReference(myEmitter.getContext()?.scope)}>`,
+                            defaultValue: `new List<${csharpType.getTypeReference(myEmitter.getContext()?.scope)}> {${defaults.join(", ")}}`,
+                            nullableType: csharpType.isNullable,
+                        };
+                    case CollectionType.Array:
+                    default:
+                        return {
+                            typeReference: code `${csharpType.getTypeReference(myEmitter.getContext()?.scope)}[]`,
+                            defaultValue: `[${defaults.join(", ")}]`,
+                            nullableType: csharpType.isNullable,
+                        };
+                }
+            case "Model":
+                let modelResult;
+                const hasUniqueItems = modelProperty
+                    ? getUniqueItems(program, modelProperty) !== undefined
+                    : false;
+                const cachedResult = this.#anonymousModels.get(tsType);
+                if (cachedResult && cachedResult.hasUniqueItems === hasUniqueItems) {
+                    return cachedResult;
+                }
+                if (isRecord(tsType)) {
+                    modelResult = {
+                        typeReference: code `${RecordType.getTypeReference(myEmitter.getContext().scope)}`,
+                        nullableType: false,
+                        hasUniqueItems: hasUniqueItems,
+                    };
+                }
+                else if (isArrayModelType(tsType)) {
+                    const typeReference = code `${this.emitter.emitTypeReference(tsType.indexer.value)}`;
+                    modelResult = isByteType(tsType.indexer.value)
+                        ? {
+                            typeReference: code `${typeReference}[]`,
+                            nullableType: false,
+                            hasUniqueItems: hasUniqueItems,
+                        }
+                        : {
+                            typeReference: hasUniqueItems
+                                ? code `ISet<${typeReference}>`
+                                : code `${this.emitter.emitTypeReference(tsType)}`,
+                            nullableType: false,
+                            hasUniqueItems: hasUniqueItems,
+                        };
+                }
+                else {
+                    modelResult = {
+                        typeReference: code `${this.emitter.emitTypeReference(tsType, this.emitter.getContext())}`,
+                        nullableType: false,
+                        hasUniqueItems: hasUniqueItems,
+                    };
+                }
+                return modelResult;
+            case "ModelProperty":
+                return this.getTypeInfo(program, tsType.type, tsType);
+            case "Enum":
+                if (getEnumType(tsType) === "double")
+                    return { typeReference: getDoubleType().getTypeReference(), nullableType: false };
+                return {
+                    typeReference: code `${this.emitter.emitTypeReference(tsType)}`,
+                    nullableType: false,
+                };
+            case "EnumMember":
+                if (typeof tsType.value === "number") {
+                    const stringValue = tsType.value.toString();
+                    if (stringValue.includes(".") || stringValue.includes("e"))
+                        return { typeReference: "double", defaultValue: stringValue, nullableType: false };
+                    return { typeReference: "int", defaultValue: stringValue, nullableType: false };
+                }
+                if (typeof tsType.value === "string") {
+                    const retVal = this.getTypeInfo(program, tsType.enum);
+                    retVal.defaultValue = `${retVal.typeReference}.${ensureCSharpIdentifier(program, tsType, tsType.name, NameCasingType.Property)}`;
+                    return retVal;
+                }
+                return { typeReference: code `object`, nullableType: false };
+            case "Union":
+                return this.getUnionInfo(program, tsType);
+            case "UnionVariant":
+                if (isStringEnumType(program, tsType.union) &&
+                    tsType.type.kind === "String" &&
+                    typeof tsType.name === "string") {
+                    const retVal = this.getUnionInfo(program, tsType.union);
+                    retVal.defaultValue = `${retVal.typeReference}.${ensureCSharpIdentifier(program, tsType, tsType.name, NameCasingType.Property)}`;
+                    return retVal;
+                }
+                return this.getTypeInfo(program, tsType.type);
+            default:
+                return {
+                    typeReference: code `${this.emitter.emitTypeReference(tsType)}`,
+                    nullableType: false,
+                };
+        }
+    }
+    getUnionInfo(program, union) {
+        const propResult = getNonNullableTsType(union);
+        if (propResult === undefined || isStringEnumType(program, union)) {
+            return {
+                typeReference: code `${this.emitter.emitTypeReference(union)}`,
+                nullableType: [...union.variants.values()].some((v) => isNullType(v.type)),
+            };
+        }
+        const candidate = this.getTypeInfo(program, propResult.type);
+        candidate.nullableType = propResult.nullable;
+        return candidate;
+    }
+}
+export function getExplicitBodyParameters(program, httpOperation) {
+    if (httpOperation.parameters.body && httpOperation.parameters.body.bodyKind === "multipart") {
+        return [
+            {
+                name: "reader",
+                callName: "reader",
+                nullable: false,
+                optional: false,
+                typeName: "MultipartReader",
+                isExplicitBody: false,
+                httpParameterKind: "body",
+                operationKind: "BusinessLogic",
+            },
+        ];
+    }
+    return undefined;
+}
+export function findNumericType(type) {
+    const stringValue = type.valueAsString;
+    if (stringValue.includes(".") || stringValue.includes("e"))
+        return ["double", stringValue];
+    return ["int", stringValue];
+}
+export function isStringEnumType(program, union) {
+    const baseType = coalesceUnionTypes(program, union);
+    if (!baseType.isBuiltIn || baseType.name !== "string")
+        return false;
+    return ![...union.variants.values()].some((v) => (v.type.kind === "String" ||
+        v.type.kind === "StringTemplate" ||
+        v.type.kind === "StringTemplateSpan") &&
+        typeof v.name !== "string");
+}
+export function coalesceUnionTypes(program, union) {
+    const [result, _] = coalesceTsTypes(program, [...union.variants.values()].flatMap((v) => v.type));
+    return result;
+}
+export function getNonNullableTsType(union) {
+    const types = [...union.variants.values()];
+    const nulls = types.flatMap((v) => v.type).filter((t) => isNullType(t));
+    const nonNulls = types.flatMap((v) => v.type).filter((t) => !isNullType(t));
+    if (nonNulls.length === 1)
+        return { type: nonNulls[0], nullable: nulls.length > 0 };
+    return undefined;
+}
+export function coalesceTsTypes(program, types) {
+    const defaultValue = [
+        new CSharpType({
+            name: "object",
+            namespace: "System",
+            isBuiltIn: true,
+            isValueType: false,
+        }),
+        true,
+    ];
+    let current = undefined;
+    let nullable = false;
+    for (const type of types) {
+        let candidate;
+        switch (type.kind) {
+            case "Boolean":
+                candidate = new CSharpType({ name: "bool", namespace: "System", isValueType: true });
+                break;
+            case "StringTemplate":
+            case "String":
+                candidate = new CSharpType({ name: "string", namespace: "System", isValueType: false });
+                break;
+            case "Number":
+                const stringValue = type.valueAsString;
+                if (stringValue.includes(".") || stringValue.includes("e")) {
+                    candidate = new CSharpType({
+                        name: "double",
+                        namespace: "System",
+                        isValueType: true,
+                    });
+                }
+                else {
+                    candidate = new CSharpType({ name: "int", namespace: "System", isValueType: true });
+                }
+                break;
+            case "Union":
+                candidate = coalesceUnionTypes(program, type);
+                break;
+            case "Scalar":
+                candidate = getCSharpTypeForScalar(program, type);
+                break;
+            case "Intrinsic":
+                if (isNullType(type)) {
+                    nullable = true;
+                    candidate = current;
+                }
+                else {
+                    return defaultValue;
+                }
+                break;
+            default:
+                return defaultValue;
+        }
+        current = current ?? candidate;
+        if (current === undefined || (candidate !== undefined && !candidate.equals(current)))
+            return defaultValue;
+    }
+    if (current !== undefined && nullable === true)
+        current.isNullable = true;
+    return current === undefined ? defaultValue : [current, false];
+}
+export function isRecord(type) {
+    return type.kind === "Model" && type.name === "Record" && type.indexer !== undefined;
+}
+export async function getFreePort(minPort, maxPort, tries = 100) {
+    const min = Math.floor(minPort);
+    const max = Math.floor(maxPort);
+    if (tries === 0)
+        return min;
+    const diff = Math.abs(max - min);
+    const port = min + Math.floor(Math.random() * diff);
+    const server = createServer();
+    const free = await checkPort(port);
+    if (free) {
+        return port;
+    }
+    // This seems like a bug? tries-- does nothing?
+    // eslint-disable-next-line no-useless-assignment
+    return await getFreePort(min, max, tries--);
+    async function checkPort(port, timeout = 100) {
+        return new Promise((resolve, _) => {
+            server.on("error", (_) => {
+                server.close();
+                resolve(false);
+            });
+            server.listen(port, async () => {
+                try {
+                    setTimeout(() => resolve(true), timeout);
+                }
+                catch (e) {
+                    resolve(false);
+                }
+                finally {
+                    server.close();
+                }
+            });
+        });
+    }
+}
+export async function getOpenApiConfig(program) {
+    const root = program.projectRoot;
+    const [options, _] = await resolveCompilerOptions(program.host, {
+        cwd: root,
+        entrypoint: resolvePath(root, "main.tsp"),
+    });
+    const oaiOptions = options.options !== undefined && Object.keys(options.options).includes("@typespec/openapi3")
+        ? options.options["@typespec/openapi3"]
+        : undefined;
+    return {
+        emitted: options.emit !== undefined && options.emit.includes("@typespec/openapi3"),
+        outputDir: oaiOptions?.["emitter-output-dir"],
+        fileName: oaiOptions?.["output-file"],
+        options: oaiOptions,
+    };
+}
+export function getStatusCode(program, model) {
+    const statusCodeProperty = new ModelInfo().filterAllProperties(program, model, (p) => isStatusCode(program, p));
+    if (!statusCodeProperty)
+        return undefined;
+    const { type } = statusCodeProperty;
+    switch (type.kind) {
+        case "Union":
+            return {
+                name: statusCodeProperty.name,
+                value: statusCodeProperty.name,
+                requiresConstructorArgument: true,
+            };
+        case "Number":
+            return {
+                value: type.value,
+            };
+        default:
+            return { value: getMinValue(program, statusCodeProperty) ?? `default` };
+    }
+}
+export function isByteType(type) {
+    return type.kind === "Scalar" && ["int8", "uint8"].includes(type.name);
+}
+export function getImports(scope, visited) {
+    if (scope === undefined)
+        return [];
+    if (!visited)
+        visited = new Set();
+    if (visited.has(scope))
+        return [];
+    visited.add(scope);
+    switch (scope.kind) {
+        case "namespace":
+            return getImports(scope.parentScope, visited);
+        case "sourceFile":
+            return [...scope.sourceFile.imports.keys()];
+        default:
+            return [];
+    }
+}
 //# sourceMappingURL=utils.js.map