@artel/artc 0.6.25254 → 0.6.25255

package/build/api/ApiServices.js

@@ -1,4 +1,5 @@
 import {
+  AccessedFunction_entity,
   AccessedFunction_typeMember,
   AliasTypeDeclarationBody,
   Analyzer,
@@ -14,6 +15,7 @@ import {
   ConfigurationConverter,
   ConfigurationDirectoryNameSet,
   ConfigurationFileParser,
+  Constructor,
   ConstructorDeclaration,
   ConstructorDeclaration_entity,
   ConstructorDeclaration_typeMember,
@@ -49,6 +51,7 @@ import {
   IndexerDeclaration_entity,
   IndexerDeclaration_typeMember,
   IndexerTranslation,
+  InferenceOptions,
   IntersectionTypeSpecifier,
   JavaScriptInterfacePackageImplementationConfig,
   JsonConfigurationFileNameSet,
@@ -105,10 +108,10 @@ import {
   StatementBlock,
   StatementList,
   StructuredTypeDeclarationBody,
+  Substitutions,
   Tag,
   TagList,
   TargetPlatformConfig,
-  TargetTypeHint,
   Token,
   TokenExpression,
   TopLevelTranslationList,
@@ -178,7 +181,7 @@ import {
   unwrapParenthesizedExpressions,
   visitChildren,
   yieldExecution
-} from "../chunk-3JS4YG6N.js";
+} from "../chunk-Y23FSWAN.js";
 
 // source/services/CustomCommand.ts
 import * as ls from "vscode-languageserver";
@@ -295,7 +298,6 @@ var SourceFileEdit = class {
 // source/services/AddPropertyAssignmentService.ts
 var AddPropertyAssignmentService = class {
   createEditWithAssignment(sourceFile, assignmentNode, value, propertyName) {
-    let result;
     let leftValueText;
     if (propertyName !== void 0) {
       if (assignmentNode.left.kind !== 76 /* MemberAccessExpression */) {
@@ -313,51 +315,28 @@ var AddPropertyAssignmentService = class {
       );
     }
     const reassignmentText = `${leftValueText} = ${value}`;
-    const subprogramBody = this.ifShouldBeAssignedAtTheEndOfSubprogramThenBody(assignmentNode);
-    if (subprogramBody !== void 0) {
-      const lastStatement = subprogramBody.expressionOrStatementList.kind === 93 /* StatementList */ ? subprogramBody.expressionOrStatementList?.statements.last() : subprogramBody.expressionOrStatementList;
-      let editRangeStart;
-      let indentationText;
-      if (lastStatement !== void 0) {
-        editRangeStart = lastStatement.rangeWithoutTrivia.end;
-        const statementStartCharacter = sourceFile.getPositionAt(lastStatement.rangeWithoutTrivia.start).character;
-        const newLine = this.detectNewLine(sourceFile.getSourceText());
-        indentationText = `${newLine}${" ".repeat(statementStartCharacter)}`;
-      } else {
-        editRangeStart = subprogramBody.openBraceToken.rangeWithoutTrivia.end;
-        indentationText = "";
-      }
-      const editText = `${indentationText}${reassignmentText}`;
-      result = new SourceFileEdit(sourceFile, Range.empty(editRangeStart), editText);
-    } else {
-      const assignmentStartPosition = sourceFile.getPositionAt(assignmentNode.rangeWithoutTrivia.start);
-      const newLine = this.detectNewLine(sourceFile.getSourceText());
-      const indentationText = `${newLine}${" ".repeat(assignmentStartPosition.character)}`;
-      const editText = `${indentationText}${reassignmentText}`;
-      result = new SourceFileEdit(sourceFile, Range.empty(assignmentNode.rangeWithoutTrivia.end), editText);
+    const subprogramBody = this.getContainingSubprogram(assignmentNode)?.block;
+    if (subprogramBody === void 0) {
+      return void 0;
     }
-    return result;
-  }
-  /**
-   * Метод определяет, где нужно расположить присваивание нового значение: сразу после присваивания предыдущего
-   * значения, или в конце подпрограммы.
-   * Если предыдущее присваивание не вложено ни в какие конструкции ветвления, присваивание нового значение можно
-   * расположить сразу после. Иначе присваивание необходимо расположить в конце подпрограммы (после всех ветвлений).
-   */
-  ifShouldBeAssignedAtTheEndOfSubprogramThenBody(node) {
-    const parent = node.parent.parent;
-    switch (parent.kind) {
-      case 94 /* StatementBlock */:
-        return this.getContainingSubprogram(parent)?.block;
-      case 95 /* FunctionBlock */:
-        return void 0;
-      default:
-        Debug.never(parent);
+    const lastStatement = subprogramBody.expressionOrStatementList.kind === 93 /* StatementList */ ? subprogramBody.expressionOrStatementList?.statements.last() : subprogramBody.expressionOrStatementList;
+    let editRangeStart;
+    let indentationText;
+    if (lastStatement !== void 0) {
+      editRangeStart = lastStatement.rangeWithoutTrivia.end;
+      const statementStartCharacter = sourceFile.getPositionAt(lastStatement.rangeWithoutTrivia.start).character;
+      const newLine = this.detectNewLine(sourceFile.getSourceText());
+      indentationText = `${newLine}${" ".repeat(statementStartCharacter)}`;
+    } else {
+      editRangeStart = subprogramBody.openBraceToken.rangeWithoutTrivia.end;
+      indentationText = "";
     }
+    const editText = `${indentationText}${reassignmentText}`;
+    return new SourceFileEdit(sourceFile, Range.empty(editRangeStart), editText);
   }
   getContainingSubprogram(node) {
     let parent = node.parent;
-    while (parent !== void 0 && !isSubprogramDeclaration(parent)) {
+    while (parent !== void 0 && !NodeTypeUtils.isSubprogramDeclarationOrLiteral(parent)) {
       parent = parent.parent;
     }
     return parent;
@@ -366,40 +345,14 @@ var AddPropertyAssignmentService = class {
     return text.includes("\r\n") ? "\r\n" : "\n";
   }
 };
-function isSubprogramDeclaration(node) {
-  switch (node.kind) {
-    case 23 /* PackageConstructorDeclaration */:
-    case 24 /* PackageEntryPointDeclaration */:
-    case 25 /* PackageFunctionDeclaration */:
-    case 34 /* PackageVariableGetterDeclaration */:
-    case 35 /* PackageVariableSetterDeclaration */:
-    case 43 /* ConstructorDeclaration */:
-    case 44 /* DestructorDeclaration */:
-    case 45 /* IndexedElementGetterDeclaration */:
-    case 46 /* IndexedElementSetterDeclaration */:
-    case 48 /* DereferencedVariableGetterDeclaration */:
-    case 49 /* DereferencedVariableSetterDeclaration */:
-    case 50 /* MethodDeclaration */:
-    case 53 /* FieldGetterDeclaration */:
-    case 54 /* FieldSetterDeclaration */:
-    case 56 /* NestedFunctionDeclaration */:
-    case 66 /* FunctionBlockLiteral */:
-    case 65 /* FunctionLiteral */:
-      return true;
-    default:
-      Debug.typeIsAssignableTo();
-      Debug.typeIsAssignableTo();
-      return false;
-  }
-}
 
-// source/tree/green/SyntaxFactory.ts
+// source/tree/SyntaxFactory.ts
 var SyntaxFactory = class {
   static sourceFile(packageImportDirectives, declarations) {
-    const packageImportDirectiveList = new PackageImportDirectiveList(packageImportDirectives);
-    const declarationList = new PackageMemberDeclarationList(declarations);
+    const packageImportDirectiveList = new PackageImportDirectiveList(packageImportDirectives, void 0);
+    const declarationList = new PackageMemberDeclarationList(declarations, void 0);
     const endOfFileToken = this.token(1 /* EndOfFile */);
-    return new SourceFile(packageImportDirectiveList, declarationList, endOfFileToken, []);
+    return new SourceFile(packageImportDirectiveList, declarationList, endOfFileToken, [], void 0);
   }
   static singlePackageImportDirective(alias, pathSegments) {
     let aliasIdentifier;
@@ -409,18 +362,18 @@ var SyntaxFactory = class {
       equalsToken = this.token(58 /* Equals */);
     }
     const packageName = this.packageName(pathSegments);
-    const packageImport = new PackageImport(aliasIdentifier, equalsToken, packageName);
+    const packageImport = new PackageImport(aliasIdentifier, equalsToken, packageName, void 0);
     const importKeyword = this.keyword(18 /* Import */);
-    return new SinglePackageImportDirective(importKeyword, packageImport);
+    return new SinglePackageImportDirective(importKeyword, packageImport, void 0);
   }
   static packageName(segments) {
     const segmentIdentifiers = segments.map((s) => this.createIdentifier(s));
     const packageNameParts = this.createTokenSeparatedElements(segmentIdentifiers, 27 /* Dot */);
-    return new PackageName(packageNameParts);
+    return new PackageName(packageNameParts, void 0);
   }
   static packageAliasTypeDeclaration(tags, modifiers, name, typeParameters, body) {
-    const tagList = new TagList(tags);
-    const modifierList = new ModifierList(modifiers);
+    const tagList = new TagList(tags, void 0);
+    const modifierList = new ModifierList(modifiers, void 0);
     const typeKeyword = this.keyword(16 /* Type */);
     const nameIdentifier = this.createIdentifier(name);
     const typeParameterClause = this.createTypeParameterClause(typeParameters);
@@ -432,28 +385,30 @@ var SyntaxFactory = class {
       nameIdentifier,
       typeParameterClause,
       equalsToken,
-      body
+      body,
+      void 0
     );
   }
   static aliasTypeDeclarationBody(aliasedTypeSpecifier, members) {
     const memberBlock = members !== void 0 ? this.typeMemberDeclarationBlock(members) : void 0;
-    return new AliasTypeDeclarationBody(aliasedTypeSpecifier, memberBlock);
+    return new AliasTypeDeclarationBody(aliasedTypeSpecifier, memberBlock, void 0);
   }
   static packageMemberGroupDeclaration(tags, modifiers, declarations) {
-    const tagList = new TagList(tags);
-    const modifierList = new ModifierList(modifiers);
-    const declarationList = new PackageMemberDeclarationList(declarations);
+    const tagList = new TagList(tags, void 0);
+    const modifierList = new ModifierList(modifiers, void 0);
+    const declarationList = new PackageMemberDeclarationList(declarations, void 0);
     return new PackageMemberGroupDeclaration(
       tagList,
       modifierList,
       this.token(44 /* OpenBrace */),
       declarationList,
-      this.token(21 /* CloseBrace */)
+      this.token(21 /* CloseBrace */),
+      void 0
     );
   }
   static packageFunctionDeclaration(tags, modifiers, name, typeParameters, parameters, returnTypeSpecifier, body) {
-    const tagList = new TagList(tags);
-    const modifierList = new ModifierList(modifiers);
+    const tagList = new TagList(tags, void 0);
+    const modifierList = new ModifierList(modifiers, void 0);
     const functionKeyword = this.keyword(12 /* Function */);
     const nameIdentifier = this.createIdentifier(name);
     const typeParameterClause = this.createTypeParameterClause(typeParameters);
@@ -467,12 +422,13 @@ var SyntaxFactory = class {
       typeParameterClause,
       parameterClause,
       returnTypeAnnotation,
-      body
+      body,
+      void 0
     );
   }
   static packageFunctionTypeDeclaration(tags, modifiers, name, typeParameters, body) {
-    const tagList = new TagList(tags);
-    const modifierList = new ModifierList(modifiers);
+    const tagList = new TagList(tags, void 0);
+    const modifierList = new ModifierList(modifiers, void 0);
     const typeKeyword = this.keyword(16 /* Type */);
     const nameIdentifier = this.createIdentifier(name);
     const typeParameterClause = this.createTypeParameterClause(typeParameters);
@@ -484,18 +440,25 @@ var SyntaxFactory = class {
       nameIdentifier,
       typeParameterClause,
       equalsToken,
-      body
+      body,
+      void 0
     );
   }
   static functionTypeDeclarationBody(parameters, returnTypeSpecifier) {
     const functionKeyword = this.keyword(12 /* Function */);
     const parameterClause = this.parameterClause(parameters);
     const returnTypeAnnotation = this.createTypeAnnotation(returnTypeSpecifier);
-    return new FunctionTypeDeclarationBody(void 0, functionKeyword, parameterClause, returnTypeAnnotation);
+    return new FunctionTypeDeclarationBody(
+      void 0,
+      functionKeyword,
+      parameterClause,
+      returnTypeAnnotation,
+      void 0
+    );
   }
   static packageStructuredTypeDeclaration(tags, modifiers, name, typeParameters, body) {
-    const tagList = new TagList(tags);
-    const modifierList = new ModifierList(modifiers);
+    const tagList = new TagList(tags, void 0);
+    const modifierList = new ModifierList(modifiers, void 0);
     const typeKeyword = this.keyword(16 /* Type */);
     const nameIdentifier = this.createIdentifier(name);
     const typeParameterClause = this.createTypeParameterClause(typeParameters);
@@ -507,22 +470,24 @@ var SyntaxFactory = class {
       nameIdentifier,
       typeParameterClause,
       equalsToken,
-      body
+      body,
+      void 0
     );
   }
   static structuredTypeDeclarationBody(structuredTypeKind, baseTypes, members) {
     const structuredTypeKindKeyword = this.keyword(structuredTypeKind);
-    const baseTypeList = baseTypes !== void 0 ? new BaseTypeList(this.createTokenSeparatedElements(baseTypes, 25 /* Comma */)) : void 0;
+    const baseTypeList = baseTypes !== void 0 ? new BaseTypeList(this.createTokenSeparatedElements(baseTypes, 25 /* Comma */), void 0) : void 0;
     const memberBlock = this.typeMemberDeclarationBlock(members);
     return new StructuredTypeDeclarationBody(
       structuredTypeKindKeyword,
       baseTypeList,
-      memberBlock
+      memberBlock,
+      void 0
     );
   }
   static packageVariableDeclaration(tags, modifiers, name, typeSpecifier, initializer) {
-    const tagList = new TagList(tags);
-    const modifierList = new ModifierList(modifiers);
+    const tagList = new TagList(tags, void 0);
+    const modifierList = new ModifierList(modifiers, void 0);
     const nameIdentifier = this.createIdentifier(name);
     const typeAnnotation = this.createTypeAnnotation(typeSpecifier);
     let equalsToken;
@@ -535,12 +500,13 @@ var SyntaxFactory = class {
       nameIdentifier,
       typeAnnotation,
       equalsToken,
-      initializer
+      initializer,
+      void 0
     );
   }
   static packageVariableGetterDeclaration(tags, modifiers, name, typeSpecifier, body) {
-    const tagList = new TagList(tags);
-    const modifierList = new ModifierList(modifiers);
+    const tagList = new TagList(tags, void 0);
+    const modifierList = new ModifierList(modifiers, void 0);
     const getKeyword = this.keyword(58 /* Get */);
     const nameIdentifier = this.createIdentifier(name);
     const typeAnnotation = this.typeAnnotation(typeSpecifier);
@@ -550,19 +516,20 @@ var SyntaxFactory = class {
       getKeyword,
       nameIdentifier,
       typeAnnotation,
-      body
+      body,
+      void 0
     );
   }
   static packageVariableSetterDeclaration(tags, modifiers, name, body) {
-    const tagList = new TagList(tags);
-    const modifierList = new ModifierList(modifiers);
+    const tagList = new TagList(tags, void 0);
+    const modifierList = new ModifierList(modifiers, void 0);
     const setKeyword = this.keyword(59 /* Set */);
     const nameIdentifier = this.createIdentifier(name);
-    return new PackageVariableSetterDeclaration(tagList, modifierList, setKeyword, nameIdentifier, body);
+    return new PackageVariableSetterDeclaration(tagList, modifierList, setKeyword, nameIdentifier, body, void 0);
   }
   static packageVariantTypeDeclaration(tags, modifiers, name, typeParameters, body) {
-    const tagList = new TagList(tags);
-    const modifierList = new ModifierList(modifiers);
+    const tagList = new TagList(tags, void 0);
+    const modifierList = new ModifierList(modifiers, void 0);
     const typeKeyword = this.keyword(16 /* Type */);
     const nameIdentifier = this.createIdentifier(name);
     const typeParameterClause = this.createTypeParameterClause(typeParameters);
@@ -574,17 +541,18 @@ var SyntaxFactory = class {
       nameIdentifier,
       typeParameterClause,
       equalsToken,
-      body
+      body,
+      void 0
     );
   }
   static variantTypeDeclarationBody(members) {
     const variantKeyword = this.keyword(6 /* Variant */);
     const memberBlock = this.typeMemberDeclarationBlock(members);
-    return new VariantTypeDeclarationBody(variantKeyword, void 0, memberBlock);
+    return new VariantTypeDeclarationBody(variantKeyword, void 0, memberBlock, void 0);
   }
   static fieldDeclaration(tags, modifiers, name, typeSpecifier, initializer) {
-    const tagList = new TagList(tags);
-    const modifierList = new ModifierList(modifiers);
+    const tagList = new TagList(tags, void 0);
+    const modifierList = new ModifierList(modifiers, void 0);
     const nameIdentifier = this.createIdentifier(name);
     const typeAnnotation = this.createTypeAnnotation(typeSpecifier);
     let equalsToken;
@@ -597,12 +565,13 @@ var SyntaxFactory = class {
       nameIdentifier,
       typeAnnotation,
       equalsToken,
-      initializer
+      initializer,
+      void 0
     );
   }
   static fieldGetterDeclaration(tags, modifiers, name, typeSpecifier, body) {
-    const tagList = new TagList(tags);
-    const modifierList = new ModifierList(modifiers);
+    const tagList = new TagList(tags, void 0);
+    const modifierList = new ModifierList(modifiers, void 0);
     const getKeyword = this.keyword(58 /* Get */);
     const nameIdentifier = this.createIdentifier(name);
     const typeAnnotation = this.typeAnnotation(typeSpecifier);
@@ -612,19 +581,20 @@ var SyntaxFactory = class {
       getKeyword,
       nameIdentifier,
       typeAnnotation,
-      body
+      body,
+      void 0
     );
   }
   static fieldSetterDeclaration(tags, modifiers, name, body) {
-    const tagList = new TagList(tags);
-    const modifierList = new ModifierList(modifiers);
+    const tagList = new TagList(tags, void 0);
+    const modifierList = new ModifierList(modifiers, void 0);
     const setKeyword = this.keyword(59 /* Set */);
     const nameIdentifier = this.createIdentifier(name);
-    return new FieldSetterDeclaration(tagList, modifierList, setKeyword, nameIdentifier, body);
+    return new FieldSetterDeclaration(tagList, modifierList, setKeyword, nameIdentifier, body, void 0);
   }
   static methodDeclaration(tags, modifiers, name, typeParameters, parameters, returnTypeSpecifier, body) {
-    const tagList = new TagList(tags);
-    const modifierList = new ModifierList(modifiers);
+    const tagList = new TagList(tags, void 0);
+    const modifierList = new ModifierList(modifiers, void 0);
     const functionKeyword = this.keyword(12 /* Function */);
     const nameIdentifier = this.createIdentifier(name);
     const typeParameterClause = this.createTypeParameterClause(typeParameters);
@@ -638,26 +608,27 @@ var SyntaxFactory = class {
       typeParameterClause,
       parameterClause,
       returnTypeAnnotation,
-      body
+      body,
+      void 0
     );
   }
   static constructorDeclaration(tags, modifiers, parameters, body) {
-    const tagList = new TagList(tags);
-    const modifierList = new ModifierList(modifiers);
+    const tagList = new TagList(tags, void 0);
+    const modifierList = new ModifierList(modifiers, void 0);
     const creationKeyword = this.keyword(31 /* Creation */);
     const parameterClause = this.parameterClause(parameters);
-    return new ConstructorDeclaration(tagList, modifierList, creationKeyword, parameterClause, body);
+    return new ConstructorDeclaration(tagList, modifierList, creationKeyword, parameterClause, body, void 0);
   }
   static destructorDeclaration(tags, modifiers, parameters, body) {
-    const tagList = new TagList(tags);
-    const modifierList = new ModifierList(modifiers);
+    const tagList = new TagList(tags, void 0);
+    const modifierList = new ModifierList(modifiers, void 0);
     const destructionKeyword = this.keyword(47 /* Destruction */);
     const parameterClause = this.parameterClause(parameters);
-    return new DestructorDeclaration(tagList, modifierList, destructionKeyword, parameterClause, body);
+    return new DestructorDeclaration(tagList, modifierList, destructionKeyword, parameterClause, body, void 0);
   }
   static indexedElementGetterDeclaration(tags, modifiers, parameters, typeSpecifier, body) {
-    const tagList = new TagList(tags);
-    const modifierList = new ModifierList(modifiers);
+    const tagList = new TagList(tags, void 0);
+    const modifierList = new ModifierList(modifiers, void 0);
     const getKeyword = this.keyword(58 /* Get */);
     const parameterClause = this.indexParameterClause(parameters);
     const typeAnnotation = this.typeAnnotation(typeSpecifier);
@@ -667,90 +638,95 @@ var SyntaxFactory = class {
       getKeyword,
       parameterClause,
       typeAnnotation,
-      body
+      body,
+      void 0
     );
   }
   static indexedElementSetterDeclaration(tags, modifiers, parameters, body) {
-    const tagList = new TagList(tags);
-    const modifierList = new ModifierList(modifiers);
+    const tagList = new TagList(tags, void 0);
+    const modifierList = new ModifierList(modifiers, void 0);
     const getKeyword = this.keyword(59 /* Set */);
     const parameterClause = this.indexParameterClause(parameters);
-    return new IndexedElementSetterDeclaration(tagList, modifierList, getKeyword, parameterClause, body);
+    return new IndexedElementSetterDeclaration(tagList, modifierList, getKeyword, parameterClause, body, void 0);
   }
   static typeMemberGroupDeclaration(tags, modifiers, members) {
-    const tagList = new TagList(tags);
-    const modifierList = new ModifierList(modifiers);
+    const tagList = new TagList(tags, void 0);
+    const modifierList = new ModifierList(modifiers, void 0);
     const memberBlock = this.typeMemberDeclarationBlock(members);
-    return new TypeMemberGroupDeclaration(tagList, modifierList, memberBlock);
+    return new TypeMemberGroupDeclaration(tagList, modifierList, memberBlock, void 0);
   }
   static typeMemberDeclarationBlock(members) {
     return new TypeMemberDeclarationBlock(
       this.token(44 /* OpenBrace */),
-      new TypeMemberDeclarationList(members),
-      this.token(21 /* CloseBrace */)
+      new TypeMemberDeclarationList(members, void 0),
+      this.token(21 /* CloseBrace */),
+      void 0
     );
   }
   static variantDeclaration(tags, modifiers, name, value) {
-    const tagList = new TagList(tags);
-    const modifierList = new ModifierList(modifiers);
+    const tagList = new TagList(tags, void 0);
+    const modifierList = new ModifierList(modifiers, void 0);
     const nameIdentifier = this.createIdentifier(name);
     let equalsToken;
     if (value !== void 0) {
       equalsToken = this.token(58 /* Equals */);
     }
-    return new VariantDeclaration(tagList, modifierList, nameIdentifier, equalsToken, value);
+    return new VariantDeclaration(tagList, modifierList, nameIdentifier, equalsToken, value, void 0);
   }
   static parameterClause(parameters) {
     return new ParameterClause(
       this.token(45 /* OpenParenthesis */),
-      new ParameterList(this.createTokenSeparatedElements(parameters, 25 /* Comma */)),
-      this.token(22 /* CloseParenthesis */)
+      new ParameterList(this.createTokenSeparatedElements(parameters, 25 /* Comma */), void 0),
+      this.token(22 /* CloseParenthesis */),
+      void 0
     );
   }
   static indexParameterClause(indexParameters) {
     return new IndexParameterClause(
       this.token(46 /* OpenSquareBracket */),
-      new ParameterList(this.createTokenSeparatedElements(indexParameters, 25 /* Comma */)),
-      this.token(23 /* CloseSquareBracket */)
+      new ParameterList(this.createTokenSeparatedElements(indexParameters, 25 /* Comma */), void 0),
+      this.token(23 /* CloseSquareBracket */),
+      void 0
     );
   }
   static namedTypeSpecifier(name, typeArguments) {
     const qualifiedNameIdentifiers = typeof name === "string" ? [this.createIdentifier(name)] : name.map((s) => this.createIdentifier(s));
     const qualifiedName = new QualifiedName(
-      this.createTokenSeparatedElements(qualifiedNameIdentifiers, 27 /* Dot */)
+      this.createTokenSeparatedElements(qualifiedNameIdentifiers, 27 /* Dot */),
+      void 0
     );
     let typeArgumentClause;
     if (typeArguments !== void 0) {
       typeArgumentClause = this.typeArgumentClause(typeArguments);
     }
-    return new NamedTypeSpecifier(qualifiedName, typeArgumentClause);
+    return new NamedTypeSpecifier(qualifiedName, typeArgumentClause, void 0);
   }
   static unionTypeSpecifier(typeSpecifiers) {
-    return new UnionTypeSpecifier(this.createTokenSeparatedElements(typeSpecifiers, 18 /* Bar */));
+    return new UnionTypeSpecifier(this.createTokenSeparatedElements(typeSpecifiers, 18 /* Bar */), void 0);
   }
   static intersectionTypeSpecifier(typeSpecifiers) {
     return new IntersectionTypeSpecifier(this.createTokenSeparatedElements(
       typeSpecifiers,
       11 /* Ampersand */
-    ));
+    ), void 0);
   }
   static nullableTypeSpecifier(typeSpecifier) {
     const questionToken = this.token(50 /* Question */);
-    return new NullableTypeSpecifier(typeSpecifier, questionToken);
+    return new NullableTypeSpecifier(typeSpecifier, questionToken, void 0);
   }
   static parenthesizedTypeSpecifier(typeSpecifier) {
     const openParenthesisToken = this.token(45 /* OpenParenthesis */);
     const closeParenthesisToken = this.token(22 /* CloseParenthesis */);
-    return new ParenthesizedTypeSpecifier(openParenthesisToken, typeSpecifier, closeParenthesisToken);
+    return new ParenthesizedTypeSpecifier(openParenthesisToken, typeSpecifier, closeParenthesisToken, void 0);
   }
   static anonymousStructuredTypeSpecifier(body) {
-    return new AnonymousTypeSpecifier(new AnonymousStructuredTypeDeclaration(body));
+    return new AnonymousTypeSpecifier(new AnonymousStructuredTypeDeclaration(body, void 0), void 0);
   }
   static anonymousFunctionTypeSpecifier(body) {
-    return new AnonymousTypeSpecifier(new AnonymousFunctionTypeDeclaration(body));
+    return new AnonymousTypeSpecifier(new AnonymousFunctionTypeDeclaration(body, void 0), void 0);
   }
   static anonymousVariantTypeSpecifier(body) {
-    return new AnonymousTypeSpecifier(new AnonymousVariantTypeDeclaration(body));
+    return new AnonymousTypeSpecifier(new AnonymousVariantTypeDeclaration(body, void 0), void 0);
   }
   static typeParameterDeclaration(name, constraint, defaultType) {
     const nameIdentifier = this.createIdentifier(name);
@@ -762,23 +738,31 @@ var SyntaxFactory = class {
     if (defaultType !== void 0) {
       equalsToken = this.token(58 /* Equals */);
     }
-    return new TypeParameterDeclaration(nameIdentifier, colonToken, constraint, equalsToken, defaultType);
+    return new TypeParameterDeclaration(
+      nameIdentifier,
+      colonToken,
+      constraint,
+      equalsToken,
+      defaultType,
+      void 0
+    );
   }
   static parameterDeclaration(tags, name, typeSpecifier, defaultValue) {
-    const tagList = new TagList(tags);
+    const tagList = new TagList(tags, void 0);
     const nameIdentifier = this.createIdentifier(name);
     const typeAnnotation = this.createTypeAnnotation(typeSpecifier);
     let equalsToken;
     if (defaultValue !== void 0) {
       equalsToken = this.token(58 /* Equals */);
     }
-    return new ParameterDeclaration(tagList, nameIdentifier, typeAnnotation, equalsToken, defaultValue);
+    return new ParameterDeclaration(tagList, nameIdentifier, typeAnnotation, equalsToken, defaultValue, void 0);
   }
   static tag(name, typeArguments, args) {
     const hashSignToken = this.token(36 /* HashSign */);
     const qualifiedNameIdentifiers = typeof name === "string" ? [this.createIdentifier(name)] : name.map((s) => this.createIdentifier(s));
     const qualifiedName = new QualifiedName(
-      this.createTokenSeparatedElements(qualifiedNameIdentifiers, 27 /* Dot */)
+      this.createTokenSeparatedElements(qualifiedNameIdentifiers, 27 /* Dot */),
+      void 0
     );
     const typeArgumentClause = typeArguments !== void 0 ? this.typeArgumentClause(typeArguments) : void 0;
     let openParenthesisToken;
@@ -787,7 +771,8 @@ var SyntaxFactory = class {
     if (args !== void 0) {
       openParenthesisToken = this.token(45 /* OpenParenthesis */);
       argumentList = new ArgumentList(
-        this.createTokenSeparatedElements(args, 25 /* Comma */)
+        this.createTokenSeparatedElements(args, 25 /* Comma */),
+        void 0
       );
       closeParenthesisToken = this.token(22 /* CloseParenthesis */);
     }
@@ -797,7 +782,8 @@ var SyntaxFactory = class {
       typeArgumentClause,
       openParenthesisToken,
       argumentList,
-      closeParenthesisToken
+      closeParenthesisToken,
+      void 0
     );
   }
   static modifier(value, level) {
@@ -810,48 +796,49 @@ var SyntaxFactory = class {
       levelKeyword = this.keyword(level);
       closeParenthesisToken = this.token(22 /* CloseParenthesis */);
     }
-    return new Modifier(valueKeyword, openParenthesisToken, levelKeyword, closeParenthesisToken);
+    return new Modifier(valueKeyword, openParenthesisToken, levelKeyword, closeParenthesisToken, void 0);
   }
   static typeArgumentClause(typeArguments) {
     const lessThanToken = this.token(37 /* LessThan */);
     const typeArgumentList = new TypeArgumentList(
-      this.createTokenSeparatedElements(typeArguments, 25 /* Comma */)
+      this.createTokenSeparatedElements(typeArguments, 25 /* Comma */),
+      void 0
     );
     const greaterThanToken = this.token(34 /* GreaterThan */);
-    return new TypeArgumentClause(lessThanToken, typeArgumentList, greaterThanToken);
+    return new TypeArgumentClause(lessThanToken, typeArgumentList, greaterThanToken, void 0);
   }
   static typeAnnotation(typeSpecifier) {
-    return new TypeAnnotation(this.token(24 /* Colon */), typeSpecifier);
+    return new TypeAnnotation(this.token(24 /* Colon */), typeSpecifier, void 0);
   }
   static statementBlock(statements) {
     const openBraceToken = this.token(44 /* OpenBrace */);
-    const statementList = new StatementList(statements);
+    const statementList = new StatementList(statements, void 0);
     const closeBraceToken = this.token(21 /* CloseBrace */);
-    return new StatementBlock(openBraceToken, statementList, closeBraceToken);
+    return new StatementBlock(openBraceToken, statementList, closeBraceToken, void 0);
   }
   static functionExpressionBlock(expression) {
     const openBraceToken = this.token(44 /* OpenBrace */);
     const closeBraceToken = this.token(21 /* CloseBrace */);
-    return new FunctionBlock(openBraceToken, expression, closeBraceToken);
+    return new FunctionBlock(openBraceToken, expression, closeBraceToken, void 0);
   }
   static functionStatementBlock(statements) {
     const openBraceToken = this.token(44 /* OpenBrace */);
-    const statementList = new StatementList(statements);
+    const statementList = new StatementList(statements, void 0);
     const closeBraceToken = this.token(21 /* CloseBrace */);
-    return new FunctionBlock(openBraceToken, statementList, closeBraceToken);
+    return new FunctionBlock(openBraceToken, statementList, closeBraceToken, void 0);
   }
   static nullLiteral() {
-    return new KeywordExpression(this.keyword(57 /* Null */));
+    return new KeywordExpression(this.keyword(57 /* Null */), void 0);
   }
   static integerLiteral(value) {
-    return new TokenExpression(this.token(2 /* IntegerLiteral */, value.toString()));
+    return new TokenExpression(this.token(2 /* IntegerLiteral */, value.toString()), void 0);
   }
   static translationsDeclaration(translations) {
-    const tagList = new TagList([]);
-    const modifierList = new ModifierList([]);
+    const tagList = new TagList([], void 0);
+    const modifierList = new ModifierList([], void 0);
     const translationsKeyword = this.keyword(55 /* Translations */);
     const openBraceToken = this.token(44 /* OpenBrace */);
-    const translationList = new TopLevelTranslationList(translations);
+    const translationList = new TopLevelTranslationList(translations, void 0);
     const closeBraceToken = this.token(21 /* CloseBrace */);
     return new TranslationsDeclaration(
       tagList,
@@ -859,14 +846,20 @@ var SyntaxFactory = class {
       translationsKeyword,
       openBraceToken,
       translationList,
-      closeBraceToken
+      closeBraceToken,
+      void 0
     );
   }
   static packageVariableTranslation(sourceName, translatedName) {
     const sourceNameIdentifier = this.createIdentifier(sourceName);
     const minusGreaterThanToken = this.token(43 /* MinusGreaterThan */);
     const translatedNameIdentifier = this.createIdentifier(translatedName);
-    return new PackageVariableTranslationDeclaration(sourceNameIdentifier, minusGreaterThanToken, translatedNameIdentifier);
+    return new PackageVariableTranslationDeclaration(
+      sourceNameIdentifier,
+      minusGreaterThanToken,
+      translatedNameIdentifier,
+      void 0
+    );
   }
   static packageFunctionTranslation(sourceName, sourceTypeParameters, sourceParameters, translatedName, translatedTypeParameters, translatedParameters) {
     const functionKeyword = this.keyword(12 /* Function */);
@@ -885,7 +878,8 @@ var SyntaxFactory = class {
       minusGreaterThanToken,
       translatedNameIdentifier,
       translatedTypeParameterClause,
-      translatedParameterClause
+      translatedParameterClause,
+      void 0
     );
   }
   static typeTranslation(sourceName, sourceTypeParameters, translatedName, translatedTypeParameters, members) {
@@ -900,7 +894,7 @@ var SyntaxFactory = class {
     let closeBraceToken;
     if (members !== void 0) {
       openBraceToken = this.token(44 /* OpenBrace */);
-      memberList = new TypeMemberTranslationList(members);
+      memberList = new TypeMemberTranslationList(members, void 0);
       closeBraceToken = this.token(21 /* CloseBrace */);
     }
     return new TypeTranslationDeclaration(
@@ -912,7 +906,8 @@ var SyntaxFactory = class {
       translatedTypeParameterClause,
       openBraceToken,
       memberList,
-      closeBraceToken
+      closeBraceToken,
+      void 0
     );
   }
   static functionTypeTranslation(sourceName, sourceTypeParameters, sourceParameters, translatedName, translatedTypeParameters, translatedParameters) {
@@ -932,7 +927,8 @@ var SyntaxFactory = class {
       minusGreaterThanToken,
       translatedNameIdentifier,
       translatedTypeParameterClause,
-      translatedParameterClause
+      translatedParameterClause,
+      void 0
     );
   }
   static fieldOrVariantTranslation(sourceName, translatedName) {
@@ -942,7 +938,8 @@ var SyntaxFactory = class {
     return new FieldOrVariantTranslation(
       sourceNameIdentifier,
       minusGreaterThanToken,
-      translatedNameIdentifier
+      translatedNameIdentifier,
+      void 0
     );
   }
   static methodTranslation(sourceName, sourceTypeParameters, sourceParameters, translatedName, translatedTypeParameters, translatedParameters) {
@@ -962,7 +959,8 @@ var SyntaxFactory = class {
       minusGreaterThanToken,
       translatedNameIdentifier,
       translatedTypeParameterClause,
-      translatedParameterClause
+      translatedParameterClause,
+      void 0
     );
   }
   static constructorTranslation(sourceParameters, translatedParameters) {
@@ -974,37 +972,50 @@ var SyntaxFactory = class {
       creationKeyword,
       sourceParameterClause,
       minusGreaterThanToken,
-      translatedParameterClause
+      translatedParameterClause,
+      void 0
     );
   }
   static indexerTranslation(sourceParameters, translatedParameters) {
     const sourceParameterClause = this.indexParameterTranslationClause(sourceParameters);
     const minusGreaterThanToken = this.token(43 /* MinusGreaterThan */);
     const translatedParameterClause = this.indexParameterTranslationClause(translatedParameters);
-    return new IndexerTranslation(sourceParameterClause, minusGreaterThanToken, translatedParameterClause);
+    return new IndexerTranslation(
+      sourceParameterClause,
+      minusGreaterThanToken,
+      translatedParameterClause,
+      void 0
+    );
   }
   static translationParameterClause(parameters) {
     const openParenthesisToken = this.token(45 /* OpenParenthesis */);
     const parameterList = new TranslationParameterList(
-      this.createTokenSeparatedElements(parameters.map((p) => this.createIdentifier(p)), 25 /* Comma */)
+      this.createTokenSeparatedElements(parameters.map((p) => this.createIdentifier(p)), 25 /* Comma */),
+      void 0
     );
     const closeParenthesisToken = this.token(22 /* CloseParenthesis */);
-    return new TranslationParameterClause(openParenthesisToken, parameterList, closeParenthesisToken);
+    return new TranslationParameterClause(openParenthesisToken, parameterList, closeParenthesisToken, void 0);
   }
   static indexParameterTranslationClause(parameters) {
     const openSquareBracketToken = this.token(46 /* OpenSquareBracket */);
     const parameterList = new TranslationParameterList(
-      this.createTokenSeparatedElements(parameters.map((p) => this.createIdentifier(p)), 25 /* Comma */)
+      this.createTokenSeparatedElements(parameters.map((p) => this.createIdentifier(p)), 25 /* Comma */),
+      void 0
     );
     const closeSquareBracketToken = this.token(23 /* CloseSquareBracket */);
-    return new IndexParameterTranslationClause(openSquareBracketToken, parameterList, closeSquareBracketToken);
+    return new IndexParameterTranslationClause(
+      openSquareBracketToken,
+      parameterList,
+      closeSquareBracketToken,
+      void 0
+    );
   }
   static token(kind, value) {
     const flags = value === void 0 ? 1 /* Missing */ : 0 /* None */;
-    return new Token(kind, value ?? "", [], flags, void 0);
+    return new Token(kind, value ?? "", [], [], flags, void 0, void 0);
   }
   static keyword(kind) {
-    return new Keyword([], kind, true);
+    return new Keyword([], kind, true, void 0);
   }
   static createTypeParameterClause(typeParameters) {
     if (typeParameters === void 0) {
@@ -1012,8 +1023,9 @@ var SyntaxFactory = class {
     }
     return new TypeParameterClause(
       this.token(37 /* LessThan */),
-      new TypeParameterList(this.createTokenSeparatedElements(typeParameters, 25 /* Comma */)),
-      this.token(34 /* GreaterThan */)
+      new TypeParameterList(this.createTokenSeparatedElements(typeParameters, 25 /* Comma */), void 0),
+      this.token(34 /* GreaterThan */),
+      void 0
     );
   }
   static createTranslationTypeParameterClause(typeParameters) {
@@ -1023,20 +1035,22 @@ var SyntaxFactory = class {
     return new TranslationTypeParameterClause(
       this.token(37 /* LessThan */),
       new TranslationTypeParameterList(
-        this.createTokenSeparatedElements(typeParameters.map((p) => this.createIdentifier(p)), 25 /* Comma */)
+        this.createTokenSeparatedElements(typeParameters.map((p) => this.createIdentifier(p)), 25 /* Comma */),
+        void 0
       ),
-      this.token(34 /* GreaterThan */)
+      this.token(34 /* GreaterThan */),
+      void 0
     );
   }
   static createTypeAnnotation(typeSpecifier) {
     if (typeSpecifier === void 0) {
       return void 0;
     }
-    return new TypeAnnotation(this.token(24 /* Colon */), typeSpecifier);
+    return new TypeAnnotation(this.token(24 /* Colon */), typeSpecifier, void 0);
   }
   static createIdentifier(value) {
     if (typeof value === "string") {
-      return new Token(10 /* Identifier */, value, [], 0 /* None */, void 0);
+      return new Token(10 /* Identifier */, value, [], [], 0 /* None */, void 0, void 0);
     }
     return value;
   }
@@ -1054,7 +1068,7 @@ var SyntaxFactory = class {
   }
 };
 
-// source/tree/green/SyntaxToCode.ts
+// source/tree/SyntaxToCode.ts
 var SyntaxToCode = class _SyntaxToCode {
   constructor(node, options6) {
     this._code = "";
@@ -2318,14 +2332,7 @@ var TokenOrKeywordsTouchingOffset_two = class {
 };
 function getTriviaAtOffset(sourceFile, offset) {
   const token = getTokenAtOffset(sourceFile, offset, true);
-  if (token !== void 0) {
-    for (const trivia of token.getLeadingTrivia()) {
-      if (trivia.range.includes(offset)) {
-        return trivia;
-      }
-    }
-  }
-  return void 0;
+  return token?.getTriviaAt(offset);
 }
 
 // source/services/TranslationsGenerationService.ts
@@ -2346,6 +2353,7 @@ var TranslationsGenerationService = class {
           analyzer,
           sourceFile,
           translationPackage,
+          sourceFile.package.locale,
           sourceFile.package.dialect
         );
         result = generator.generateMissingTypeMemberTranslations(tokenOrKeyword.parent);
@@ -2358,6 +2366,7 @@ var TranslationsGenerationService = class {
           analyzer,
           sourceFile,
           translationPackage,
+          sourceFile.package.locale,
           sourceFile.package.dialect
         );
         if (onlyTypeMembers) {
@@ -2384,15 +2393,22 @@ var TranslationsGenerationService = class {
     if (translationPackage === void 0) {
       return false;
     }
-    const generator = new TranslationsGenerator(analyzer, sourceFile, translationPackage, sourceFile.package.dialect);
+    const generator = new TranslationsGenerator(
+      analyzer,
+      sourceFile,
+      translationPackage,
+      sourceFile.package.locale,
+      sourceFile.package.dialect
+    );
     return Query.from(tokenOrKeyword.parent.translationList.translationDeclarations).filter((t) => t.kind === 142 /* TypeTranslationDeclaration */).mapAndFilter((t) => translationPackage.getTypeTranslationTarget(t).target).any((t) => generator.collectNotTranslatedTypeMembers(t).length > 0);
   }
 };
 var TranslationsGenerator = class _TranslationsGenerator {
-  constructor(_analyzer, _sourceFile, _translationPackage, _dialect) {
+  constructor(_analyzer, _sourceFile, _translationPackage, _locale, _dialect) {
     this._analyzer = _analyzer;
     this._sourceFile = _sourceFile;
     this._translationPackage = _translationPackage;
+    this._locale = _locale;
     this._dialect = _dialect;
   }
   static {
@@ -2404,7 +2420,7 @@ var TranslationsGenerator = class _TranslationsGenerator {
     if (memberEntities.length > 0) {
       const newLine = this.detectNewLine();
       const syntaxToCodeOptions = {
-        keywordsLocale: this._translationPackage.getTargetPackage().getLocale(),
+        keywordsLocale: this._locale,
         keywordsDialect: this._dialect,
         initialIndentation: this.detectIndentationForPackageMemberTranslations(translationsDeclaration),
         indentationStep: this.detectIndentationStepForTypeMemberTranslations(translationsDeclaration),
@@ -2464,7 +2480,7 @@ var TranslationsGenerator = class _TranslationsGenerator {
     }
     const newLine = this.detectNewLine();
     const syntaxToCodeOptions = {
-      keywordsLocale: this._translationPackage.getTargetPackage().getLocale(),
+      keywordsLocale: this._locale,
       keywordsDialect: this._dialect,
       initialIndentation: this.detectIndentationForTypeMemberTranslations(typeTranslation),
       indentationStep: this.detectIndentationStepForTypeMemberTranslations(typeTranslation),
@@ -2721,7 +2737,7 @@ var CodeActionsService = class {
     }
     const result = new Array();
     const diagnosticCodeSet = new Set(diagnosticCodes);
-    if (diagnosticCodeSet.has(277 /* TheFollowingDeclarationsAreNotTranslated0 */) || diagnosticCodeSet.has(278 /* TheFollowingDeclarationAreNotTranslated0And1More */)) {
+    if (diagnosticCodeSet.has(281 /* TheFollowingDeclarationsAreNotTranslated0 */) || diagnosticCodeSet.has(282 /* TheFollowingDeclarationAreNotTranslated0And1More */)) {
       const data = { onlyTypeMembers: false };
       result.push(CodeAction.unresolved(
         "\u0421\u0433\u0435\u043D\u0435\u0440\u0438\u0440\u043E\u0432\u0430\u0442\u044C \u043D\u0435\u0434\u043E\u0441\u0442\u0430\u044E\u0449\u0438\u0435 \u043F\u0435\u0440\u0435\u0432\u043E\u0434\u044B.",
@@ -2833,38 +2849,92 @@ var SignatureForNode = class _SignatureForNode {
     }
   }
   static getSignaturesForCallExpression(analyzer, node) {
-    const meaning = analyzer.getCallExpressionMeaning(node);
-    if (meaning.kind === "constructor-call") {
-      let suitableSignatureIndex;
-      if (meaning.suitableConstructors.length === 1) {
-        suitableSignatureIndex = meaning.candidates.indexOf(meaning.suitableConstructors[0]);
+    const meaning = analyzer.resolveCallExpression(node).meaning;
+    switch (meaning.kind) {
+      case "function-call": {
+        let suitableSignatureIndex;
+        let functions;
+        if (meaning.singleNotSuitableSubstitutedCandidate !== void 0) {
+          functions = [meaning.singleNotSuitableSubstitutedCandidate];
+        } else {
+          const singleFunction = meaning.singleSuitableFunction;
+          if (singleFunction !== void 0) {
+            suitableSignatureIndex = meaning.candidates.findIndex((f) => f.getEntity().getOriginalEntity() === singleFunction.getEntity().getOriginalEntity());
+          }
+          functions = [];
+          for (const candidate of meaning.candidates) {
+            const suitableFunction = meaning.suitableFunctions.find((s) => s.getEntity().getOriginalEntity() === candidate.getEntity().getOriginalEntity());
+            functions.push(suitableFunction ?? candidate);
+          }
+        }
+        const signatures = functions.map((f) => {
+          if (f.kind === "substituted-function") {
+            const substitutions = f.value.getSubstitutions();
+            if (substitutions.size > 0 && Query.from(substitutions.getTypes()).all((t) => t.kind === "unresolved")) {
+              switch (f.value.kind) {
+                case "entity":
+                  f = new AccessedFunction_entity(f.value.entity);
+                  break;
+                case "type-member":
+                  f = new AccessedFunction_typeMember(f.value.method);
+                  break;
+                default:
+                  Debug.never(f.value);
+              }
+            }
+          }
+          return new AccessedFunctionSignature(f);
+        });
+        return new SignaturesWithSingleSuitable(signatures, suitableSignatureIndex);
       }
-      const signatures = meaning.candidates.map((c) => new ConstructorSignature(c));
-      return new SignaturesWithSingleSuitable(signatures, suitableSignatureIndex);
-    }
-    const info = analyzer.checkExpressionDenotesFunction(node.expression);
-    if (info !== void 0) {
-      let suitableSignatureIndex;
-      if (info.suitableFunctions.length === 1) {
-        suitableSignatureIndex = info.candidates.indexOf(info.suitableFunctions[0]);
+      case "operator-call": {
+        let suitableSignatureIndex;
+        const singleOperator = meaning.singleOperator;
+        if (singleOperator !== void 0) {
+          suitableSignatureIndex = meaning.candidates.findIndex((c) => c.equals(singleOperator));
+        }
+        const signatures = meaning.candidates.map((c) => new OperatorSignature(c));
+        return new SignaturesWithSingleSuitable(signatures, suitableSignatureIndex);
       }
-      const signatures = info.candidates.map((c) => new AccessedFunctionSignature(c));
-      return new SignaturesWithSingleSuitable(signatures, suitableSignatureIndex);
-    }
-    if (meaning.kind === "object-function-call") {
-      const signature = new FunctionTypeSignature(meaning.type);
-      return new SignaturesWithSingleSuitable([signature], 0);
+      case "object-function-call": {
+        const signature = new FunctionTypeSignature(meaning.type);
+        return new SignaturesWithSingleSuitable([signature], 0);
+      }
+      case "constructor-call": {
+        let suitableSignatureIndex;
+        let constructors;
+        if (meaning.singleNotSuitableSubstitutedCandidate !== void 0) {
+          constructors = [meaning.singleNotSuitableSubstitutedCandidate];
+        } else {
+          const singleConstructor = meaning.singleSuitableConstructor;
+          if (singleConstructor !== void 0) {
+            suitableSignatureIndex = meaning.candidates.findIndex((f) => f.getEntity().getOriginalEntity() === singleConstructor.getEntity().getOriginalEntity());
+          }
+          constructors = [];
+          for (const candidate of meaning.candidates) {
+            const suitableConstructor = meaning.suitableConstructors.find((s) => s.getEntity().getOriginalEntity() === candidate.getEntity().getOriginalEntity());
+            constructors.push(suitableConstructor ?? candidate);
+          }
+        }
+        const signatures = this.getSignaturesOfConstructors(analyzer, constructors);
+        return new SignaturesWithSingleSuitable(signatures, suitableSignatureIndex);
+      }
+      case "unresolved": {
+        return void 0;
+      }
+      default:
+        Debug.never(meaning);
     }
-    return void 0;
   }
   static getSignaturesForAutotypeCallExpression(analyzer, node) {
-    const meaning = analyzer.getAutotypeCallExpressionMeaning(node);
+    const meaning = analyzer.resolveAutotypeCallExpression(node).meaning;
     if (meaning.kind === "constructor-call") {
       let suitableSignatureIndex;
-      if (meaning.suitableConstructors.length === 1) {
-        suitableSignatureIndex = meaning.candidates.indexOf(meaning.suitableConstructors[0]);
+      const singleConstructor = meaning.singleConstructor;
+      if (singleConstructor !== void 0) {
+        suitableSignatureIndex = meaning.candidates.findIndex((c) => c.equals(singleConstructor));
       }
-      const signatures = meaning.candidates.map((c) => new ConstructorSignature(c));
+      const signatures = this.getSignaturesOfConstructors(analyzer, meaning.candidates);
       return new SignaturesWithSingleSuitable(signatures, suitableSignatureIndex);
     }
     return void 0;
@@ -2874,8 +2944,9 @@ var SignatureForNode = class _SignatureForNode {
     switch (meaning.kind) {
       case "resolved": {
         let suitableSignatureIndex;
-        if (meaning.singleSuitableIndexer !== void 0) {
-          suitableSignatureIndex = meaning.candidates.indexOf(meaning.singleSuitableIndexer);
+        const singleIndexer = meaning.singleIndexer;
+        if (singleIndexer !== void 0) {
+          suitableSignatureIndex = meaning.candidates.findIndex((i) => i.equals(singleIndexer));
         }
         const signatures = meaning.candidates.map((i) => new IndexerSignature(i));
         return new SignaturesWithSingleSuitable(signatures, suitableSignatureIndex);
@@ -2890,16 +2961,18 @@ var SignatureForNode = class _SignatureForNode {
     const meaning = analyzer.resolveTag(node).meaning;
     if (meaning.kind === "tag-type") {
       let suitableSignatureIndex;
-      if (meaning.suitableConstructors.length === 1) {
-        suitableSignatureIndex = meaning.candidates.indexOf(meaning.suitableConstructors[0]);
+      const singleConstructor = meaning.singleConstructor;
+      if (singleConstructor !== void 0) {
+        suitableSignatureIndex = meaning.candidates.findIndex((c) => c.equals(singleConstructor));
       }
-      const signatures = meaning.candidates.map((c) => new ConstructorSignature(c));
+      const signatures = this.getSignaturesOfConstructors(analyzer, meaning.candidates);
       return new SignaturesWithSingleSuitable(signatures, suitableSignatureIndex);
     }
     if (meaning.kind === "tag-function") {
       let suitableSignatureIndex;
-      if (meaning.suitableFunctions.length === 1) {
-        suitableSignatureIndex = meaning.candidates.indexOf(meaning.suitableFunctions[0]);
+      const singleFunction = meaning.singleFunction;
+      if (singleFunction !== void 0) {
+        suitableSignatureIndex = meaning.candidates.findIndex((f) => f.getEntity().getOriginalEntity() === singleFunction.getEntity().getOriginalEntity());
       }
       const signatures = meaning.candidates.map((c) => new AccessedFunctionSignature(c));
       return new SignaturesWithSingleSuitable(signatures, suitableSignatureIndex);
@@ -2909,6 +2982,16 @@ var SignatureForNode = class _SignatureForNode {
     }
     Debug.never(meaning);
   }
+  static getSignaturesOfConstructors(analyzer, constructors) {
+    return constructors.map((c) => {
+      const substitutions = c.getSubstitutions();
+      if (substitutions.size > 0 && Query.from(substitutions.getTypes()).all((t) => t.kind === "unresolved")) {
+        const identitySubstitutions = Substitutions.identity(analyzer, Array.from(substitutions.getParameters()));
+        c = new Constructor(analyzer, c.getEntity(), identitySubstitutions);
+      }
+      return new ConstructorSignature(c);
+    });
+  }
 };
 var SimplifiedArgumentToParameterMatcher = class {
   static match(analyzer, arguments_, signature) {
@@ -2968,7 +3051,10 @@ var SimplifiedOverloadResolver = class _SimplifiedOverloadResolver {
         continue;
       }
       const targetParameterType = targetParameter.getType();
-      const argumentType = analyzer.type.ofExpression(argument.expression, new TargetTypeHint(targetParameterType));
+      const argumentType = analyzer.type.ofExpression(
+        argument.expression,
+        new InferenceOptions(targetParameterType, false, false)
+      );
       if (analyzer.isTypeAssignableTo(argumentType, targetParameterType)) {
         continue;
       }
@@ -3022,6 +3108,16 @@ var AccessedFunctionSignature = class {
     return this._valueParameters.getOrInsertWith(() => this.func.getValueParameters().map((p) => new UniversalValueParameter(p.type, p.entity)));
   }
 };
+var OperatorSignature = class {
+  constructor(operator) {
+    this.kind = "operator";
+    this._valueParameters = new Cached();
+    this.operator = operator;
+  }
+  getValueParameters() {
+    return this._valueParameters.getOrInsertWith(() => this.operator.getValueParameters().map((p) => new UniversalValueParameter(p.getType(), p.getEntity())));
+  }
+};
 var FunctionTypeSignature = class {
   constructor(functionType) {
     this.kind = "function-type";
@@ -3172,7 +3268,7 @@ var CompletionService = class {
     }
     if (tokenOrKeyword.isToken(27 /* Dot */) && tokenOrKeyword.parent.kind === 9 /* PackageName */) {
       const packageImport = tokenOrKeyword.parent.parent;
-      const precedingSegmentNames = packageImport.packageName.segments.takeWhile((s) => s.rangeStart < tokenOrKeyword.value.rangeStart).map((p) => this._analyzer.createNameFromIdentifier(p)).toArray();
+      const precedingSegmentNames = packageImport.packageName.segments.takeWhile((s) => s.rangeWithTrivia.start < tokenOrKeyword.value.rangeWithTrivia.start).map((p) => this._analyzer.createNameFromIdentifier(p)).toArray();
       return new PackageImportCompletionContext(precedingSegmentNames, void 0);
     }
     if (tokenOrKeyword.isToken(44 /* OpenBrace */) && tokenOrKeyword.parent.kind === 6 /* PackageGroupImportDirective */ || this.tokenOrKeywordIsPackageImportListChild(tokenOrKeyword)) {
@@ -3363,7 +3459,7 @@ var CompletionService = class {
     if (tokenOrKeyword.isToken(27 /* Dot */) && tokenOrKeyword.parent.kind === 138 /* QualifiedName */) {
       const qualifiedName = tokenOrKeyword.parent;
       if (qualifiedName.parent.kind === 137 /* PackageImportTranslationDeclaration */ && qualifiedName === qualifiedName.parent.sourceName) {
-        const precedingSegmentNames = qualifiedName.qualifiers.takeWhile((s) => s.rangeStart < tokenOrKeyword.value.rangeStart).map((p) => this._analyzer.createNameFromIdentifier(p)).toArray();
+        const precedingSegmentNames = qualifiedName.qualifiers.takeWhile((s) => s.rangeWithTrivia.start < tokenOrKeyword.value.rangeWithTrivia.start).map((p) => this._analyzer.createNameFromIdentifier(p)).toArray();
         const sourceLocale = translationPackage.getTargetPackage().getLocale();
         return new PackageImportCompletionContext(precedingSegmentNames, { sourceLocale });
       }
@@ -4255,7 +4351,7 @@ function isInvalidNode(node) {
     case 0 /* Token */:
       return node.isMissing;
     case 3 /* Keyword */:
-      return node.green.isMissing;
+      return node.isMissing;
     default:
       return false;
   }
@@ -5351,12 +5447,12 @@ var SyntaxContextFactory = class {
       trivia = getTriviaAtOffset(sourceFile.getSyntaxNode(), offset - 1);
     }
     if (trivia?.kind === 1 /* NewLine */) {
-      const previousTrivia = getTriviaAtOffset(sourceFile.getSyntaxNode(), trivia.range.start - 1);
-      if (previousTrivia?.kind === 2 /* SingleLineComment */) {
+      const previousTrivia = getTriviaAtOffset(sourceFile.getSyntaxNode(), offset - trivia.range.length);
+      if (previousTrivia?.trivia.kind === 2 /* SingleLineComment */) {
         trivia = previousTrivia;
       }
     }
-    return trivia !== void 0 && offset > trivia.rangeStart && (trivia.kind === 2 /* SingleLineComment */ || trivia.kind === 3 /* MultiLineComment */);
+    return trivia !== void 0 && offset > trivia.range.start && (trivia.kind === 2 /* SingleLineComment */ || trivia.kind === 3 /* MultiLineComment */);
   }
   static isInStringOrChar(sourceFile, offset) {
     let token = getTokenAtOffset(sourceFile.getSyntaxNode(), offset, false);
@@ -5891,20 +5987,34 @@ var NodeSemanticInfoService = class {
         result = new ReferenceNodeSemanticInfo([target], false);
         break;
       }
-      case "instance-method-access":
-        if (isNonEmptyArray(meaning.suitableFunctions)) {
-          result = createAccessedFunctionsReference(meaning.suitableFunctions, meaning.suitableFunctions.length > 1);
+      case "instance-method-access": {
+        let functions;
+        if (meaning.singleNotSuitableSubstitutedCandidate !== void 0) {
+          functions = [meaning.singleNotSuitableSubstitutedCandidate];
+        } else if (isNonEmptyArray(meaning.suitableFunctions)) {
+          functions = meaning.suitableFunctions;
         } else if (isNonEmptyArray(meaning.candidates)) {
-          result = createAccessedFunctionsReference(meaning.candidates, true);
+          functions = meaning.candidates;
+        }
+        if (functions !== void 0) {
+          result = this.ofAccessedFunctions(functions);
         }
         break;
-      case "static-method-access":
-        if (isNonEmptyArray(meaning.suitableFunctions)) {
-          result = createAccessedFunctionsReference(meaning.suitableFunctions, meaning.suitableFunctions.length > 1);
+      }
+      case "static-method-access": {
+        let functions;
+        if (meaning.singleNotSuitableSubstitutedCandidate !== void 0) {
+          functions = [meaning.singleNotSuitableSubstitutedCandidate];
+        } else if (isNonEmptyArray(meaning.suitableFunctions)) {
+          functions = meaning.suitableFunctions;
         } else if (isNonEmptyArray(meaning.candidates)) {
-          result = createAccessedFunctionsReference(meaning.candidates, true);
+          functions = meaning.candidates;
+        }
+        if (functions !== void 0) {
+          result = this.ofAccessedFunctions(functions);
         }
         break;
+      }
       case "operator-access": {
         if (isNonEmptyArray(meaning.suitableOperators)) {
           result = createOperatorsReference(meaning.suitableOperators, meaning.suitableOperators.length > 1);
@@ -5913,21 +6023,49 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case "package-function-access":
-        if (isNonEmptyArray(meaning.suitableFunctions)) {
-          result = createAccessedFunctionsReference(meaning.suitableFunctions, meaning.suitableFunctions.length > 1);
+      case "package-function-access": {
+        let functions;
+        if (meaning.singleNotSuitableSubstitutedCandidate !== void 0) {
+          functions = [meaning.singleNotSuitableSubstitutedCandidate];
+        } else if (isNonEmptyArray(meaning.suitableFunctions)) {
+          functions = meaning.suitableFunctions;
         } else if (isNonEmptyArray(meaning.candidates)) {
-          result = createAccessedFunctionsReference(meaning.candidates, true);
+          functions = meaning.candidates;
+        }
+        if (functions !== void 0) {
+          result = this.ofAccessedFunctions(functions);
         }
         break;
+      }
       case "package-type-access":
-        if (meaning.suitableTypes.length === 0 && meaning.candidates.length > 0) {
+        if (meaning.suitableTypes.length > 0) {
+          const targets = meaning.suitableTypes.map((c) => {
+            const entity = c.getEntity();
+            if (entity !== void 0) {
+              return new EntityReferenceTarget(entity, 0 /* Get */);
+            } else {
+              return void 0;
+            }
+          }).filter((t) => t !== void 0);
+          result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), meaning.suitableTypes.length > 1);
+        } else if (meaning.candidates.length > 0) {
           const targets = meaning.candidates.map((c) => new EntityReferenceTarget(c, 0 /* Get */));
           result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
-        } else {
-          result = this.ofMaybeConstructorCallExpression(analyzer, meaning.suitableTypes, node, options6);
         }
         break;
+      case "constructor-access": {
+        const callExpressionMeaning = meaning.callExpressionMeaning;
+        result = this.ofConstructorCallWithTypeAccess(
+          analyzer,
+          callExpressionMeaning.typeEntity,
+          meaning.typeCandidates,
+          callExpressionMeaning.singleNotSuitableSubstitutedCandidate,
+          callExpressionMeaning.suitableConstructors,
+          callExpressionMeaning.candidates,
+          options6
+        );
+        break;
+      }
       case "package-name-segment-access":
         result = this.ofPackageNameSegmentAccess(analyzer, meaning.packageTreeNode, node);
         break;
@@ -5947,10 +6085,6 @@ var NodeSemanticInfoService = class {
       result = this.getBetterReferenceTargetsOrPreserve(result);
     }
     return result;
-    function createAccessedFunctionsReference(functions, isAmbiguous) {
-      const targets = functions.map((o) => new AccessedFunctionReferenceTarget(o));
-      return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), isAmbiguous);
-    }
     function createOperatorsReference(operators, isAmbiguous) {
       const targets = operators.map((o) => new OperatorReferenceTarget(o));
       return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), isAmbiguous);
@@ -6029,7 +6163,7 @@ var NodeSemanticInfoService = class {
       const resolvedQualifier = resolutionResult.resolvedQualifiers[qualifierIndex];
       switch (resolvedQualifier.kind) {
         case "type": {
-          if (options6.preferredTargetOfExplicitConstructorCall === "type-declaration" || resolutionResult.meaning.kind !== "tag-type") {
+          if (resolutionResult.meaning.kind !== "tag-type") {
             if (resolvedQualifier.suitableTypes.length > 0) {
               const targets = resolvedQualifier.suitableTypes.map((t) => new EntityReferenceTarget(t, 0 /* Get */));
               result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), targets.length > 1);
@@ -6038,25 +6172,31 @@ var NodeSemanticInfoService = class {
               result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
             }
           } else {
-            if (resolutionResult.meaning.suitableConstructors.length > 0) {
-              const targets = resolutionResult.meaning.suitableConstructors.map((t) => new ConstructorReferenceTarget(t));
-              result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), targets.length > 1);
-            } else if (resolutionResult.meaning.candidates.length > 0) {
-              const targets = resolutionResult.meaning.candidates.map((t) => new ConstructorReferenceTarget(t));
-              result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
-            }
+            const typeEntity = resolvedQualifier.suitableTypes.length === 1 ? resolvedQualifier.suitableTypes[0] : void 0;
+            result = this.ofConstructorCallWithTypeAccess(
+              analyzer,
+              typeEntity,
+              resolvedQualifier.candidates,
+              resolutionResult.meaning.singleNotSuitableSubstitutedCandidate,
+              resolutionResult.meaning.suitableConstructors,
+              resolutionResult.meaning.candidates,
+              options6
+            );
           }
           break;
         }
-        case "function":
+        case "function": {
+          let functions;
           if (resolvedQualifier.suitableFunctions.length > 0) {
-            const targets = resolvedQualifier.suitableFunctions.map((t) => new EntityReferenceTarget(t, 0 /* Get */));
-            result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), targets.length > 1);
+            functions = resolvedQualifier.suitableFunctions;
           } else if (resolvedQualifier.candidates.length > 0) {
-            const targets = resolvedQualifier.candidates.map((t) => new EntityReferenceTarget(t, 0 /* Get */));
-            result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
+            functions = resolvedQualifier.candidates;
+          }
+          if (functions !== void 0) {
+            result = this.ofAccessedFunctions(functions);
           }
           break;
+        }
         case "package-name-segment": {
           let currentIndex = qualifierIndex;
           while (currentIndex + 1 < resolutionResult.resolvedQualifiers.length && resolutionResult.resolvedQualifiers[currentIndex + 1].kind === "package-name-segment") {
@@ -6104,20 +6244,48 @@ var NodeSemanticInfoService = class {
     const meaning = analyzer.resolveIdentifierExpression(node).meaning;
     switch (meaning.kind) {
       case "type-access":
-        if (meaning.suitableTypes.length === 0 && meaning.candidates.length > 0) {
+        if (meaning.suitableTypes.length > 0) {
+          const targets = meaning.suitableTypes.map((c) => {
+            const entity = c.getEntity();
+            if (entity !== void 0) {
+              return new EntityReferenceTarget(entity, 0 /* Get */);
+            } else {
+              return void 0;
+            }
+          }).filter((t) => t !== void 0);
+          result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), meaning.suitableTypes.length > 1);
+        } else if (meaning.candidates.length > 0) {
           const targets = meaning.candidates.map((c) => new EntityReferenceTarget(c, 0 /* Get */));
           result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
-        } else {
-          result = this.ofMaybeConstructorCallExpression(analyzer, meaning.suitableTypes, node, options6);
         }
         break;
-      case "function-access":
-        if (isNonEmptyArray(meaning.suitableFunctions)) {
-          result = createAccessedFunctionsReference(meaning.suitableFunctions, meaning.suitableFunctions.length > 1);
+      case "constructor-access": {
+        const callExpressionMeaning = meaning.callExpressionMeaning;
+        result = this.ofConstructorCallWithTypeAccess(
+          analyzer,
+          callExpressionMeaning.typeEntity,
+          meaning.typeCandidates,
+          callExpressionMeaning.singleNotSuitableSubstitutedCandidate,
+          callExpressionMeaning.suitableConstructors,
+          callExpressionMeaning.candidates,
+          options6
+        );
+        break;
+      }
+      case "function-access": {
+        let functions;
+        if (meaning.singleNotSuitableSubstitutedCandidate !== void 0) {
+          functions = [meaning.singleNotSuitableSubstitutedCandidate];
+        } else if (isNonEmptyArray(meaning.suitableFunctions)) {
+          functions = meaning.suitableFunctions;
         } else if (isNonEmptyArray(meaning.candidates)) {
-          result = createAccessedFunctionsReference(meaning.candidates, true);
+          functions = meaning.candidates;
+        }
+        if (functions !== void 0) {
+          result = this.ofAccessedFunctions(functions);
         }
         break;
+      }
       case "operator-access": {
         if (isNonEmptyArray(meaning.suitableOperators)) {
           result = createOperatorsReference(meaning.suitableOperators, meaning.suitableOperators.length > 1);
@@ -6183,10 +6351,6 @@ var NodeSemanticInfoService = class {
       result = this.getBetterReferenceTargetsOrPreserve(result);
     }
     return result;
-    function createAccessedFunctionsReference(functions, isAmbiguous) {
-      const targets = functions.map((o) => new AccessedFunctionReferenceTarget(o));
-      return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), isAmbiguous);
-    }
     function createOperatorsReference(operators, isAmbiguous) {
       const targets = operators.map((o) => new OperatorReferenceTarget(o));
       return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), isAmbiguous);
@@ -6283,15 +6447,17 @@ var NodeSemanticInfoService = class {
     return void 0;
   }
   static ofAutotypeCallExpression(analyzer, node, options6) {
-    const meaning = analyzer.getAutotypeCallExpressionMeaning(node);
+    const meaning = analyzer.resolveAutotypeCallExpression(node).meaning;
     let result;
     if (meaning.kind === "constructor-call") {
+      let constructors;
       if (meaning.suitableConstructors.length > 0) {
-        const targets = meaning.suitableConstructors.map((c) => new ConstructorReferenceTarget(c));
-        result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), meaning.suitableConstructors.length > 1);
+        constructors = meaning.suitableConstructors;
       } else if (meaning.candidates.length > 0) {
-        const targets = meaning.candidates.map((c) => new ConstructorReferenceTarget(c));
-        result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
+        constructors = meaning.candidates;
+      }
+      if (constructors !== void 0) {
+        result = this.ofConstructors(analyzer, constructors);
       }
     }
     if (result !== void 0 && options6.includeBetterReferenceTargets) {
@@ -6304,12 +6470,14 @@ var NodeSemanticInfoService = class {
     let result;
     switch (meaning.kind) {
       case "own-constructor-access": {
+        let constructors;
         if (meaning.suitableConstructors.length > 0) {
-          const targets = meaning.suitableConstructors.map((c) => new ConstructorReferenceTarget(c));
-          result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), meaning.suitableConstructors.length > 1);
+          constructors = meaning.suitableConstructors;
         } else if (meaning.candidates.length > 0) {
-          const targets = meaning.candidates.map((c) => new ConstructorReferenceTarget(c));
-          result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
+          constructors = meaning.candidates;
+        }
+        if (constructors !== void 0) {
+          result = this.ofConstructors(analyzer, constructors);
         }
         break;
       }
@@ -6334,12 +6502,14 @@ var NodeSemanticInfoService = class {
     let result;
     switch (meaning.kind) {
       case "base-constructor-access": {
+        let constructors;
         if (meaning.suitableConstructors.length > 0) {
-          const targets = meaning.suitableConstructors.map((c) => new ConstructorReferenceTarget(c));
-          result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), meaning.suitableConstructors.length > 1);
+          constructors = meaning.suitableConstructors;
         } else if (meaning.candidates.length > 0) {
-          const targets = meaning.candidates.map((c) => new ConstructorReferenceTarget(c));
-          result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
+          constructors = meaning.candidates;
+        }
+        if (constructors !== void 0) {
+          result = this.ofConstructors(analyzer, constructors);
         }
         break;
       }
@@ -6349,9 +6519,7 @@ var NodeSemanticInfoService = class {
         break;
       }
       case "overridden-method-access": {
-        const target = new AccessedFunctionReferenceTarget(new AccessedFunction_typeMember(meaning.method));
-        result = new ReferenceNodeSemanticInfo([target], false);
-        break;
+        return this.ofAccessedFunctions([meaning.method]);
       }
       case "overridden-operator-access": {
         const target = new OperatorReferenceTarget(meaning.operator);
@@ -6384,42 +6552,24 @@ var NodeSemanticInfoService = class {
     }
     return new ReferenceNodeSemanticInfo([new PackageReferenceTarget(packageTreeNode.package)], false);
   }
-  static ofMaybeConstructorCallExpression(analyzer, types, typeAccessExpression, options6) {
-    if (types.length === 0) {
-      return void 0;
+  static ofConstructorCallWithTypeAccess(analyzer, suitableType, typeCandidates, singleNotSuitableSubstitutedCandidate, suitableConstructors, candidates, options6) {
+    if (options6.preferredTargetOfExplicitConstructorCall === "type-declaration") {
+      const targets2 = suitableType !== void 0 ? [new EntityReferenceTarget(suitableType, 0 /* Get */)] : typeCandidates.map((t) => new EntityReferenceTarget(t, 0 /* Get */));
+      return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets2), targets2.length > 1);
     }
-    const typeEntities = Query.from(types).mapAndFilter((t) => t.getEntity()).toArray();
-    if (options6.preferredTargetOfExplicitConstructorCall === "type-declaration" && typeEntities.length > 0) {
-      const targets = typeEntities.map((t) => new EntityReferenceTarget(t, 0 /* Get */));
-      return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), targets.length > 1);
+    let constructors;
+    if (singleNotSuitableSubstitutedCandidate !== void 0) {
+      constructors = [singleNotSuitableSubstitutedCandidate];
+    } else if (suitableConstructors.length > 0) {
+      constructors = suitableConstructors;
+    } else if (candidates.length > 0) {
+      constructors = candidates;
     }
-    const parent = getParentSkippingParenthesizedExpressions(typeAccessExpression);
-    let parentCallExpression;
-    if (parent.kind === 68 /* CallExpression */) {
-      parentCallExpression = parent;
-    } else if (parent.kind === 90 /* GenericSpecializationExpression */) {
-      const grandParent = getParentSkippingParenthesizedExpressions(parent);
-      if (grandParent.kind === 68 /* CallExpression */) {
-        parentCallExpression = grandParent;
-      }
+    if (constructors !== void 0) {
+      return this.ofConstructors(analyzer, constructors);
     }
-    if (parentCallExpression !== void 0) {
-      const meaning = analyzer.getCallExpressionMeaning(parentCallExpression);
-      if (meaning.kind === "constructor-call") {
-        if (meaning.suitableConstructors.length > 0) {
-          const targets = meaning.suitableConstructors.map((c) => new ConstructorReferenceTarget(c));
-          return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), meaning.suitableConstructors.length > 1);
-        } else if (meaning.candidates.length > 0) {
-          const targets = meaning.candidates.map((c) => new ConstructorReferenceTarget(c));
-          return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
-        }
-      }
-    }
-    if (typeEntities.length > 0) {
-      const targets = typeEntities.map((t) => new EntityReferenceTarget(t, 0 /* Get */));
-      return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), targets.length > 1);
-    }
-    return void 0;
+    const targets = suitableType !== void 0 ? [new EntityReferenceTarget(suitableType, 0 /* Get */)] : typeCandidates.map((t) => new EntityReferenceTarget(t, 0 /* Get */));
+    return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), targets.length > 1);
   }
   static getBetterReferenceTargetsOrPreserve(info) {
     const currentTargets = info.betterTargets ?? info.targets;
@@ -6476,6 +6626,38 @@ var NodeSemanticInfoService = class {
     }
     return void 0;
   }
+  static ofAccessedFunctions(functions) {
+    functions = functions.map((f) => {
+      if (f.kind === "substituted-function") {
+        const substitutions = f.value.getSubstitutions();
+        if (substitutions.size > 0 && Query.from(substitutions.getTypes()).all((t) => t.kind === "unresolved")) {
+          switch (f.value.kind) {
+            case "entity":
+              return new AccessedFunction_entity(f.value.entity);
+            case "type-member":
+              return new AccessedFunction_typeMember(f.value.method);
+            default:
+              Debug.never(f.value);
+          }
+        }
+      }
+      return f;
+    });
+    const targets = functions.map((f) => new AccessedFunctionReferenceTarget(f));
+    return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), targets.length > 1);
+  }
+  static ofConstructors(analyzer, constructors) {
+    constructors = constructors.map((c) => {
+      const substitutions = c.getSubstitutions();
+      if (substitutions.size > 0 && Query.from(substitutions.getTypes()).all((t) => t.kind === "unresolved")) {
+        const identitySubstitutions = Substitutions.identity(analyzer, Array.from(substitutions.getParameters()));
+        return new Constructor(analyzer, c.getEntity(), identitySubstitutions);
+      }
+      return c;
+    });
+    const targets = constructors.map((c) => new ConstructorReferenceTarget(c));
+    return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), targets.length > 1);
+  }
 };
 var DefinitionNodeSemanticInfo = class {
   constructor(entity) {
@@ -8224,8 +8406,10 @@ var SelectionRangeService = class {
       const child = nodeWithChildren.children.find((c) => c !== void 0 && this.nodeContainsOffset(c, offset, false));
       if (child === void 0) {
         const trivia = getTriviaAtOffset(sourceFile.getSyntaxNode(), offset);
-        if (trivia?.kind === 3 /* MultiLineComment */ || trivia?.kind === 2 /* SingleLineComment */) {
-          result = new SelectionRange(trivia.range, result);
+        if (trivia !== void 0) {
+          if (trivia.kind === 3 /* MultiLineComment */ || trivia.kind === 2 /* SingleLineComment */) {
+            result = new SelectionRange(trivia.range, result);
+          }
         }
         break;
       }
@@ -8659,12 +8843,7 @@ var TypeParameterSignatureHelpProvider = class {
         return Query.from(lastQualifier.candidates).mapAndFilter((t) => this.getSignatureForNamedType(t)).toArray();
       } else if (lastQualifier.kind === "function") {
         if (resolutionResult.meaning.kind === "tag-function") {
-          return Query.from(resolutionResult.meaning.candidates).mapAndFilter((d) => {
-            if (d.kind === "substituted-function") {
-              return this.getSignatureForSubstitutedFunction(d.value);
-            }
-            return void 0;
-          }).toArray();
+          return Query.from(resolutionResult.meaning.candidates).mapAndFilter((f) => this.getSignatureForAccessedFunction(f)).toArray();
         } else {
           return void 0;
         }
@@ -8677,16 +8856,14 @@ var TypeParameterSignatureHelpProvider = class {
     if (expression.kind === 89 /* IdentifierExpression */) {
       const meaning = this._analyzer.resolveIdentifierExpression(expression).meaning;
       if (meaning.kind === "function-access") {
-        return Query.from(meaning.candidates).mapAndFilter((o) => {
-          if (o.kind === "substituted-function") {
-            return this.getSignatureForSubstitutedFunction(o.value);
-          }
-          return void 0;
-        }).toArray();
+        return Query.from(meaning.candidates).mapAndFilter((f) => this.getSignatureForAccessedFunction(f)).toArray();
       }
       if (meaning.kind === "type-access") {
         return Query.from(meaning.candidates).mapAndFilter((t) => this.getSignatureForNamedType(t)).toArray();
       }
+      if (meaning.kind === "constructor-access") {
+        return Query.from(meaning.typeCandidates).mapAndFilter((t) => this.getSignatureForNamedType(t)).toArray();
+      }
       return void 0;
     }
     if (expression.kind === 76 /* MemberAccessExpression */) {
@@ -8700,33 +8877,48 @@ var TypeParameterSignatureHelpProvider = class {
         accessedFunctions = meaning.candidates;
       }
       if (accessedFunctions !== void 0) {
-        return Query.from(accessedFunctions).mapAndFilter((o) => {
-          if (o.kind === "substituted-function") {
-            return this.getSignatureForSubstitutedFunction(o.value);
-          }
-          return void 0;
-        }).toArray();
+        return Query.from(accessedFunctions).mapAndFilter((f) => this.getSignatureForAccessedFunction(f)).toArray();
       }
       if (meaning.kind === "package-type-access") {
         return Query.from(meaning.candidates).mapAndFilter((t) => this.getSignatureForNamedType(t)).toArray();
       }
+      if (meaning.kind === "constructor-access") {
+        return Query.from(meaning.typeCandidates).mapAndFilter((t) => this.getSignatureForNamedType(t)).toArray();
+      }
       return void 0;
     }
     return void 0;
   }
-  getSignatureForSubstitutedFunction(func) {
+  getSignatureForAccessedFunction(func) {
     let result = void 0;
     switch (func.kind) {
       case "entity":
-        if (func.entity.getTypeParametersArity() > 0) {
-          result = new FunctionEntitySignature(this.signatureContext, func.entity);
+        if (func.getTypeParameters().length > 0) {
+          result = new FunctionEntitySignature(this.signatureContext, func.value);
         }
         break;
       case "type-member":
-        if (func.method.getTypeParametersArity() > 0) {
-          result = new MethodSignature(this.signatureContext, func.method);
+        if (func.getTypeParameters().length > 0) {
+          result = new MethodSignature(this.signatureContext, func.value);
         }
         break;
+      case "substituted-function": {
+        switch (func.value.kind) {
+          case "entity":
+            if (func.getTypeParameters().length > 0) {
+              result = new FunctionEntitySignature(this.signatureContext, func.value.entity);
+            }
+            break;
+          case "type-member":
+            if (func.getTypeParameters().length > 0) {
+              result = new MethodSignature(this.signatureContext, func.value.method);
+            }
+            break;
+          default:
+            Debug.never(func.value);
+        }
+        break;
+      }
       default:
         Debug.never(func);
     }
@@ -8993,6 +9185,11 @@ var ValueParametersSignatureHelpProvider = class {
         const displayParts = this.signatureContext.displayService.getFunctionDeclarationDisplayParts(func);
         return this.signatureContext.convertFunctionDisplayParts(displayParts);
       }
+      case "operator": {
+        const operator = new OperatorDeclaration_typeMember(signature.operator);
+        const displayParts = this.signatureContext.displayService.getOperatorDeclarationDisplayParts(operator);
+        return this.signatureContext.convertOperatorDisplayParts(displayParts);
+      }
       case "function-type": {
         const displayParts = this.signatureContext.displayService.getFunctionTypeBodyDisplayParts(signature.functionType);
         return this.signatureContext.convertFunctionTypeBodyDisplayParts(displayParts);
@@ -9027,6 +9224,12 @@ var SignatureContext2 = class {
     const postfix = parts.valueParametersEnd + parts.returnTypeAnnotationColon + parts.returnType;
     return new SignatureDisplayParts(prefix, valueParameters, parts.valueParameterSeparator, postfix);
   }
+  convertOperatorDisplayParts(parts) {
+    const prefix = parts.functionKeyword + parts.whitespaceAfterFunctionKeyword + parts.container + parts.name + parts.valueParametersStart;
+    const valueParameters = parts.valueParameters.map((p) => p.toString());
+    const postfix = parts.valueParametersEnd + parts.returnTypeAnnotationColon + parts.returnType;
+    return new SignatureDisplayParts(prefix, valueParameters, parts.valueParameterSeparator, postfix);
+  }
   convertFunctionTypeBodyDisplayParts(parts) {
     const prefix = parts.asyncKeywordWithWhitespace + parts.functionKeyword + parts.valueParametersStart;
     const valueParameters = parts.valueParameters.map((p) => p.toString());