Revert "Revise accessor resolution logic and error reporting (microsoft#48459)"

This reverts commit df7ed82.

Author: njuptw

src/compiler/checker.ts

@@ -172,7 +172,6 @@ namespace ts {
         EnumTagType,
         ResolvedTypeArguments,
         ResolvedBaseTypes,
-        WriteType,
     }
 
     const enum CheckMode {
@@ -8530,8 +8529,6 @@ namespace ts {
                     return !!(target as TypeReference).resolvedTypeArguments;
                 case TypeSystemPropertyName.ResolvedBaseTypes:
                     return !!(target as InterfaceType).baseTypesResolved;
-                case TypeSystemPropertyName.WriteType:
-                    return !!getSymbolLinks(target as Symbol).writeType;
             }
             return Debug.assertNever(propertyName);
         }
@@ -9515,11 +9512,6 @@ namespace ts {
                 }
                 return getWidenedType(getWidenedLiteralType(checkExpression(declaration.statements[0].expression)));
             }
-            if (isAccessor(declaration)) {
-                // Binding of certain patterns in JS code will occasionally mark symbols as both properties
-                // and accessors. Here we dispatch to accessor resolution if needed.
-                return getTypeOfAccessors(symbol);
-            }
 
             // Handle variable, parameter or property
             if (!pushTypeResolution(symbol, TypeSystemPropertyName.Type)) {
@@ -9585,6 +9577,9 @@ namespace ts {
             else if (isEnumMember(declaration)) {
                 type = getTypeOfEnumMember(symbol);
             }
+            else if (isAccessor(declaration)) {
+                type = resolveTypeOfAccessors(symbol) || Debug.fail("Non-write accessor resolution must always produce a type");
+            }
             else {
                 return Debug.fail("Unhandled declaration kind! " + Debug.formatSyntaxKind(declaration.kind) + " for " + Debug.formatSymbol(symbol));
             }
@@ -9629,62 +9624,97 @@ namespace ts {
 
         function getTypeOfAccessors(symbol: Symbol): Type {
             const links = getSymbolLinks(symbol);
-            if (!links.type) {
-                if (!pushTypeResolution(symbol, TypeSystemPropertyName.Type)) {
-                    return errorType;
-                }
+            return links.type || (links.type = getTypeOfAccessorsWorker(symbol) || Debug.fail("Read type of accessor must always produce a type"));
+        }
+
+        function getTypeOfSetAccessor(symbol: Symbol): Type | undefined {
+            const links = getSymbolLinks(symbol);
+            return links.writeType || (links.writeType = getTypeOfAccessorsWorker(symbol, /*writing*/ true));
+        }
+
+        function getTypeOfAccessorsWorker(symbol: Symbol, writing = false): Type | undefined {
+            if (!pushTypeResolution(symbol, TypeSystemPropertyName.Type)) {
+                return errorType;
+            }
+
+            let type = resolveTypeOfAccessors(symbol, writing);
+            if (!popTypeResolution()) {
                 const getter = getDeclarationOfKind<AccessorDeclaration>(symbol, SyntaxKind.GetAccessor);
-                const setter = getDeclarationOfKind<AccessorDeclaration>(symbol, SyntaxKind.SetAccessor);
-                // We try to resolve a getter type annotation, a setter type annotation, or a getter function
-                // body return type inference, in that order.
-                let type = getter && isInJSFile(getter) && getTypeForDeclarationFromJSDocComment(getter) ||
-                    getAnnotatedAccessorType(getter) ||
-                    getAnnotatedAccessorType(setter) ||
-                    getter && getter.body && getReturnTypeFromBody(getter);
-                if (!type) {
-                    if (setter && !isPrivateWithinAmbient(setter)) {
-                        errorOrSuggestion(noImplicitAny, setter, Diagnostics.Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation, symbolToString(symbol));
-                    }
-                    else if (getter && !isPrivateWithinAmbient(getter)) {
-                        errorOrSuggestion(noImplicitAny, getter, Diagnostics.Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation, symbolToString(symbol));
-                    }
-                    type = anyType;
-                }
-                if (!popTypeResolution()) {
-                    if (getAnnotatedAccessorTypeNode(getter)) {
-                        error(getter, Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol));
+                if (getter) {
+                    if (getEffectiveTypeAnnotationNode(getter)) {
+                        error(getter.name, Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol));
                     }
-                    else if (getAnnotatedAccessorTypeNode(setter)) {
-                        error(setter, Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol));
-                    }
-                    else if (getter && noImplicitAny) {
+                    else if (noImplicitAny) {
                         error(getter, Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, symbolToString(symbol));
                     }
-                    type = anyType;
                 }
-                links.type = type;
+                type = anyType;
             }
-            return links.type;
+            return type;
         }
 
-        function getWriteTypeOfAccessors(symbol: Symbol): Type {
-            const links = getSymbolLinks(symbol);
-            if (!links.writeType) {
-                if (!pushTypeResolution(symbol, TypeSystemPropertyName.WriteType)) {
-                    return errorType;
+        function resolveTypeOfAccessors(symbol: Symbol, writing = false) {
+            const getter = getDeclarationOfKind<AccessorDeclaration>(symbol, SyntaxKind.GetAccessor);
+            const setter = getDeclarationOfKind<AccessorDeclaration>(symbol, SyntaxKind.SetAccessor);
+
+            // For write operations, prioritize type annotations on the setter
+            if (writing) {
+                const setterType = getAnnotatedAccessorType(setter);
+                if (setterType) {
+                    return instantiateTypeIfNeeded(setterType, symbol);
                 }
-                const setter = getDeclarationOfKind<AccessorDeclaration>(symbol, SyntaxKind.SetAccessor);
-                let writeType = getAnnotatedAccessorType(setter);
-                if (!popTypeResolution()) {
-                    if (getAnnotatedAccessorTypeNode(setter)) {
-                        error(setter, Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol));
-                    }
-                    writeType = anyType;
+            }
+            // Else defer to the getter type
+
+            if (getter && isInJSFile(getter)) {
+                const jsDocType = getTypeForDeclarationFromJSDocComment(getter);
+                if (jsDocType) {
+                    return instantiateTypeIfNeeded(jsDocType, symbol);
                 }
-                // Absent an explicit setter type annotation we use the read type of the accessor.
-                links.writeType = writeType || getTypeOfAccessors(symbol);
             }
-            return links.writeType;
+
+            // Try to see if the user specified a return type on the get-accessor.
+            const getterType = getAnnotatedAccessorType(getter);
+            if (getterType) {
+                return instantiateTypeIfNeeded(getterType, symbol);
+            }
+
+            // If the user didn't specify a return type, try to use the set-accessor's parameter type.
+            const setterType = getAnnotatedAccessorType(setter);
+            if (setterType) {
+                return setterType;
+            }
+
+            // If there are no specified types, try to infer it from the body of the get accessor if it exists.
+            if (getter && getter.body) {
+                const returnTypeFromBody = getReturnTypeFromBody(getter);
+                return instantiateTypeIfNeeded(returnTypeFromBody, symbol);
+            }
+
+            // Otherwise, fall back to 'any'.
+            if (setter) {
+                if (!isPrivateWithinAmbient(setter)) {
+                    errorOrSuggestion(noImplicitAny, setter, Diagnostics.Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation, symbolToString(symbol));
+                }
+                return anyType;
+            }
+            else if (getter) {
+                Debug.assert(!!getter, "there must exist a getter as we are current checking either setter or getter in this function");
+                if (!isPrivateWithinAmbient(getter)) {
+                    errorOrSuggestion(noImplicitAny, getter, Diagnostics.Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation, symbolToString(symbol));
+                }
+                return anyType;
+            }
+            return undefined;
+
+            function instantiateTypeIfNeeded(type: Type, symbol: Symbol) {
+                if (getCheckFlags(symbol) & CheckFlags.Instantiated) {
+                    const links = getSymbolLinks(symbol);
+                    return instantiateType(type, links.mapper);
+                }
+
+                return type;
+            }
         }
 
         function getBaseTypeVariableOfClass(symbol: Symbol) {
@@ -9772,12 +9802,17 @@ namespace ts {
 
         function getTypeOfInstantiatedSymbol(symbol: Symbol): Type {
             const links = getSymbolLinks(symbol);
-            return links.type || (links.type = instantiateType(getTypeOfSymbol(links.target!), links.mapper));
-        }
-
-        function getWriteTypeOfInstantiatedSymbol(symbol: Symbol): Type {
-            const links = getSymbolLinks(symbol);
-            return links.writeType || (links.writeType = instantiateType(getWriteTypeOfSymbol(links.target!), links.mapper));
+            if (!links.type) {
+                if (!pushTypeResolution(symbol, TypeSystemPropertyName.Type)) {
+                    return links.type = errorType;
+                }
+                let type = instantiateType(getTypeOfSymbol(links.target!), links.mapper);
+                if (!popTypeResolution()) {
+                    type = reportCircularityError(symbol);
+                }
+                links.type = type;
+            }
+            return links.type;
         }
 
         function reportCircularityError(symbol: Symbol) {
@@ -9820,23 +9855,36 @@ namespace ts {
         }
 
         /**
-         * Distinct write types come only from set accessors, but synthetic union and intersection
-         * properties deriving from set accessors will either pre-compute or defer the union or
-         * intersection of the writeTypes of their constituents.
+         * Distinct write types come only from set accessors, but union and intersection
+         * properties deriving from set accessors will either pre-compute or defer the
+         * union or intersection of the writeTypes of their constituents. To account for
+         * this, we will assume that any deferred type or transient symbol may have a
+         * `writeType` (or a deferred write type ready to be computed) that should be
+         * used before looking for set accessor declarations.
          */
         function getWriteTypeOfSymbol(symbol: Symbol): Type {
             const checkFlags = getCheckFlags(symbol);
-            if (symbol.flags & SymbolFlags.Property) {
-                return checkFlags & CheckFlags.SyntheticProperty ?
-                    checkFlags & CheckFlags.DeferredType ?
-                        getWriteTypeOfSymbolWithDeferredType(symbol) || getTypeOfSymbolWithDeferredType(symbol) :
-                        (symbol as TransientSymbol).writeType || (symbol as TransientSymbol).type! :
-                    getTypeOfSymbol(symbol);
+            if (checkFlags & CheckFlags.DeferredType) {
+                const writeType = getWriteTypeOfSymbolWithDeferredType(symbol);
+                if (writeType) {
+                    return writeType;
+                }
+            }
+            if (symbol.flags & SymbolFlags.Transient) {
+                const { writeType } = symbol as TransientSymbol;
+                if (writeType) {
+                    return writeType;
+                }
             }
+            return getSetAccessorTypeOfSymbol(symbol);
+        }
+
+        function getSetAccessorTypeOfSymbol(symbol: Symbol): Type {
             if (symbol.flags & SymbolFlags.Accessor) {
-                return checkFlags & CheckFlags.Instantiated ?
-                    getWriteTypeOfInstantiatedSymbol(symbol) :
-                    getWriteTypeOfAccessors(symbol);
+                const type = getTypeOfSetAccessor(symbol);
+                if (type) {
+                    return type;
+                }
             }
             return getTypeOfSymbol(symbol);
         }
@@ -25199,7 +25247,7 @@ namespace ts {
                 }
             }
             if (isDeclarationName(location) && isSetAccessor(location.parent) && getAnnotatedAccessorTypeNode(location.parent)) {
-                return getWriteTypeOfAccessors(location.parent.symbol);
+                return resolveTypeOfAccessors(location.parent.symbol, /*writing*/ true)!;
             }
             // The location isn't a reference to the given symbol, meaning we're being asked
             // a hypothetical question of what type the symbol would have if there was a reference

src/compiler/utilitiesPublic.ts

@@ -1335,9 +1335,7 @@ namespace ts {
             || kind === SyntaxKind.CallSignature
             || kind === SyntaxKind.PropertySignature
             || kind === SyntaxKind.MethodSignature
-            || kind === SyntaxKind.IndexSignature
-            || kind === SyntaxKind.GetAccessor
-            || kind === SyntaxKind.SetAccessor;
+            || kind === SyntaxKind.IndexSignature;
     }
 
     export function isClassOrTypeElement(node: Node): node is ClassElement | TypeElement {