Function getFlowTypeOfAccessExpression

test/fixtures/snapshot/typescript.js:74751–74798

(node, prop, propType, errorNode, checkMode)

            return false;
        }
        function getFlowTypeOfAccessExpression(node, prop, propType, errorNode, checkMode) {
            // Only compute control flow type if this is a property access expression that isn't an
            // assignment target, and the referenced property was declared as a variable, property,
            // accessor, or optional method.
            var assignmentKind = ts.getAssignmentTargetKind(node);
            if (assignmentKind === 1 /* AssignmentKind.Definite */) {
                return removeMissingType(propType, !!(prop && prop.flags & 16777216 /* SymbolFlags.Optional */));
            }
            if (prop &&
                !(prop.flags & (3 /* SymbolFlags.Variable */ | 4 /* SymbolFlags.Property */ | 98304 /* SymbolFlags.Accessor */))
                && !(prop.flags & 8192 /* SymbolFlags.Method */ && propType.flags & 1048576 /* TypeFlags.Union */)
                && !isDuplicatedCommonJSExport(prop.declarations)) {
                return propType;
            }
            if (propType === autoType) {
                return getFlowTypeOfProperty(node, prop);
            }
            propType = getNarrowableTypeForReference(propType, node, checkMode);
            // If strict null checks and strict property initialization checks are enabled, if we have
            // a this.xxx property access, if the property is an instance property without an initializer,
            // and if we are in a constructor of the same class as the property declaration, assume that
            // the property is uninitialized at the top of the control flow.
            var assumeUninitialized = false;
            if (strictNullChecks && strictPropertyInitialization && ts.isAccessExpression(node) && node.expression.kind === 108 /* SyntaxKind.ThisKeyword */) {
                var declaration = prop && prop.valueDeclaration;
                if (declaration && isPropertyWithoutInitializer(declaration)) {
                    if (!ts.isStatic(declaration)) {
                        var flowContainer = getControlFlowContainer(node);
                        if (flowContainer.kind === 171 /* SyntaxKind.Constructor */ && flowContainer.parent === declaration.parent && !(declaration.flags & 16777216 /* NodeFlags.Ambient */)) {
                            assumeUninitialized = true;
                        }
                    }
                }
            }
            else if (strictNullChecks && prop && prop.valueDeclaration &&
                ts.isPropertyAccessExpression(prop.valueDeclaration) &&
                ts.getAssignmentDeclarationPropertyAccessKind(prop.valueDeclaration) &&
                getControlFlowContainer(node) === getControlFlowContainer(prop.valueDeclaration)) {
                assumeUninitialized = true;
            }
            var flowType = getFlowTypeOfReference(node, propType, assumeUninitialized ? getOptionalType(propType) : propType);
            if (assumeUninitialized && !(getFalsyFlags(propType) & 32768 /* TypeFlags.Undefined */) && getFalsyFlags(flowType) & 32768 /* TypeFlags.Undefined */) {
                error(errorNode, ts.Diagnostics.Property_0_is_used_before_being_assigned, symbolToString(prop)); // TODO: GH#18217
                // Return the declared type to reduce follow-on errors
                return propType;
            }
            return assignmentKind ? getBaseTypeOfLiteralType(flowType) : flowType;
        }
        function checkPropertyNotUsedBeforeDeclaration(prop, node, right) {
            var valueDeclaration = prop.valueDeclaration;
            if (!valueDeclaration || ts.getSourceFileOfNode(node).isDeclarationFile) {