// Check if a parameter, catch variable, or mutable local variable is assigned anywhere definitely

function isSymbolAssignedDefinitely(symbol: Symbol) {

if (symbol.lastAssignmentPos !== undefined) {

return symbol.lastAssignmentPos < 0;

}

return isSymbolAssigned(symbol) && symbol.lastAssignmentPos !== undefined && symbol.lastAssignmentPos < 0;

}

// Check if a parameter, catch variable, or mutable local variable is assigned anywhere

return !symbol.lastAssignmentPos || location && Math.abs(symbol.lastAssignmentPos) < location.pos;

const assigmentTarget = getAssignmentTargetKind(node);

if (assigmentTarget !== AssignmentKind.None) {

const hasDefiniteAssignment = assigmentTarget === AssignmentKind.Definite || (symbol.lastAssignmentPos !== undefined && symbol.lastAssignmentPos < 0);

if (isParameterOrMutableLocalVariable(symbol)) {

if (symbol.lastAssignmentPos === undefined || Math.abs(symbol.lastAssignmentPos) !== Number.MAX_VALUE) {

const referencingFunction = findAncestor(node, isFunctionOrSourceFile);

const declaringFunction = findAncestor(symbol.valueDeclaration, isFunctionOrSourceFile);

symbol.lastAssignmentPos = referencingFunction === declaringFunction ? extendAssignmentPosition(node, symbol.valueDeclaration!) : Number.MAX_VALUE;

}

if (hasDefiniteAssignment && symbol.lastAssignmentPos > 0) {

symbol.lastAssignmentPos *= -1;

}

const sign = symbol.lastAssignmentPos !== undefined && symbol.lastAssignmentPos < 0 ? -1 : 1;

symbol.lastAssignmentPos = sign * Number.MAX_VALUE;

const immediateDeclaration = declaration;

const isNeverInitialized = immediateDeclaration && isVariableDeclaration(immediateDeclaration) && !immediateDeclaration.initializer && !immediateDeclaration.exclamationToken && isMutableLocalVariableDeclaration(immediateDeclaration) && !isSymbolAssignedDefinitely(symbol);

const assumeInitialized = isParameter || isAlias ||

(isOuterVariable && !isNeverInitialized) ||

isSpreadDestructuringAssignmentTarget || isModuleExports || isSameScopedBindingElement(node, declaration) ||

// Only report unused parameters on the implementation, not overloads.

if (node.body) {

None = 0,

let enabledSubstitutions = ClassPropertySubstitutionFlags.None;

None = 0,

let enabledSubstitutions = ES2015SubstitutionFlags.None;

None = 0,

let enabledSubstitutions = ES2017SubstitutionFlags.None;

None = 0,

let enabledSubstitutions = ESNextSubstitutionFlags.None;

None = 0,

let enabledSubstitutions = TypeScriptSubstitutionFlags.None;

/** @internal */ lastAssignmentPos?: number; // Source position of last node that assigns value to symbol. Negative if it is assigned anywhere definitely

ForInStatement,

ForOfStatement,

case SyntaxKind.ForInStatement:

case SyntaxKind.ForOfStatement:

return node === (parent as ForInStatement | ForOfStatement).initializer ? AccessKind.Write : AccessKind.Read;

narrowingPastLastAssignment.ts(161,9): error TS18048: 'foo' is possibly 'undefined'.

==== narrowingPastLastAssignment.ts (3 errors) ====

function f13() {

// Test for captured 'var' declaration (as opposed to parameters, let, const).

var foo: string | undefined;

foo = '';

return () => {

foo.toLocaleLowerCase();

~~~

!!! error TS18048: 'foo' is possibly 'undefined'.

}

}