Method FindUpVar

source/script.cpp:7157–7223

Var *Script::FindUpVar(LPCTSTR aVarName, UserFunc &aInner, ResultType *aDisplayError)
{
	// Do not search outer if inner is *explicitly* assume-global, since in that case a
	// global var should be returned in preference to anything defined by outer.
	if (aInner.mDefaultVarType == VAR_DECLARE_GLOBAL)
		return nullptr;
	auto &outer = *aInner.mOuterFunc;
	Var *outer_var;
	if (  (outer_var = outer.mStaticVars.Find(aVarName))  )
		return outer_var;
	if (  !(outer_var = outer.mVars.Find(aVarName))
		&& !(outer.mOuterFunc && (outer_var = FindUpVar(aVarName, outer, aDisplayError)))  )
		return nullptr;
	// At this point, all var refs used in declarations, assignments or &var in the outer
	// function should have already been parsed, while it's possible that some read-refs
	// have not.  Ignore all variables that lack an assignment, &var or declaration.
	//  - Avoids an issue where only read-refs ABOVE the nested function are accessible
	//    (which could also be fixed by changing PreparseVarRefs to parse one function
	//    at a time, parsing outer in its entirety before inner).
	//  - Avoids inconsistency between read-refs and write-refs: when the outer var is created
	//    by a read-ref, closures which only read would capture it, while closures which write
	//    would create their own local.
	//  - Avoids having behaviour depend on whether a global exists: when outer and inner both
	//    only use read-refs (but maybe assign dynamically), whether the nested function becomes
	//    a closure might depend on whether the var is global or local to outer.
	//  - Having a non-dynamic assignment (and no global declaration) makes it easier to see
	//    that the var is local by looking at just the outer function, and avoids warnings.
	//  - A clear rule is easier to remember.
	if (  !(outer_var->IsAssignedSomewhere() || outer_var->IsDeclared())  )
		return nullptr;
	// Since this local variable is not static, things need to be set up so that the inner
	// function will capture it as an upvar at the appropriate time.
	if (mIsReadyToExecute)
	{
		// This dynamic reference resolved to a variable that hasn't been captured by the
		// current function, so is not safe to return.
		if (aDisplayError)
			*aDisplayError = RuntimeError(ERR_DYNAMIC_UPVAR, aVarName);
		return nullptr;
	}
	ASSERT(!outer.mDownVar && !aInner.mUpVar); // PreprocessLocalVars has not yet been called.
	if (!(outer_var->Scope() & VAR_DOWNVAR))
	{
		outer.mDownVarCount++;
		outer_var->Scope() |= VAR_DOWNVAR;
	}
	// At this point aInner doesn't have a variable by this name, so create one:
	int insert_pos;
	aInner.mVars.Find(aVarName, &insert_pos);
	Var *inner_var = AddVar(aVarName, 0, &aInner.mVars, insert_pos, VAR_LOCAL | VAR_DECLARED); // VAR_DECLARED suppresses checking for a global for #Warn LocalSameAsGlobal or when #Warn UseUnset is triggered.
	if (!inner_var)
	{
		if (aDisplayError)
			*aDisplayError = FAIL; // Error already displayed.
		return nullptr;
	}
	ASSERT(outer_var->Type() != VAR_CONSTANT || outer_var->HasObject() && dynamic_cast<UserFunc*>(outer_var->Object()));
	bool indefinite = outer_var->Type() == VAR_CONSTANT && !((UserFunc *)outer_var->Object())->mUpVarCount;