internal VariableDef CreateTypedVariable(Node node, AnalysisUnit unit, string name, IAnalysisSet types, bool addRef = true)
{
VariableDef res, outer, immediateOuter;
if (!Variables.TryGetValue(name, out res))
{
// Normal CreateVariable would use AddVariable, which will put
// the typed one in the wrong scope.
res = base.AddVariable(name);
}
if (addRef)
{
res.AddReference(node, unit);
}
PropagateIsInstanceTypes(node, unit, types, res);
outer = OuterScope.GetVariable(node, unit, name, addRef);
if (OuterScope.Variables.TryGetValue(name, out immediateOuter) && immediateOuter != res)
{
if (addRef && immediateOuter != outer)
{
res.AddReference(node, unit);
}
PropagateIsInstanceTypes(node, unit, types, immediateOuter);
OuterScope.GetLinkedVariables(name).Add(res);
}
return(res);
}
private EvaluationResult GetOrEvalField(Context context, SymbolAtom name, ModuleLiteral startEnv, bool recurs, ModuleLiteral origin, LineInfo location)
{
// This logic is still used only V1 evaluation
if (IsFileModule && name == context.Names.Qualifier)
{
// Someone references 'qualifier' on the file level.
return(EvaluationResult.Create(Qualifier.Qualifier));
}
ModuleBinding binding = null;
// TODO:ST: sounds reasonable to add "warning" if name was resolved but it is not exposed!
if (m_bindings?.TryGetValue(name, out binding) == true && (recurs || binding.IsExported))
{
return(GetOrEvalFieldBinding(context, name, binding, location));
}
if (recurs && OuterScope != null)
{
return(OuterScope.GetOrEvalField(context, name, startEnv, true, origin, location));
}
context.Errors.ReportMissingMember(origin ?? startEnv, name, startEnv, location);
return(EvaluationResult.Error);
}
internal virtual bool IsTargetForSort(int index, bool detailSort)
{
if (OuterScope != null)
{
return(OuterScope.Value().IsTargetForSort(index, detailSort));
}
return(false);
}
static void Main()
{
DateTime now = DateTime.UtcNow;
OuterScope outer = new OuterScope();
outer.hour = now.Hour;
if (outer.hour > 5)
{
InnerScope inner = new InnerScope();
inner.minute = now.Minute;
PrintValues(ref outer, ref inner);
}
}
public Symbol FindSymbol(string Name)
{
// Check self
var s = Symbols.FindLocalSymbol(Name);
if (s!=null)
return s;
// Check outer scope
if (OuterScope != null)
return OuterScope.FindSymbol(Name);
// Not defined
return null;
}
public override bool AssignVariable(string name, Node location, AnalysisUnit unit, IAnalysisSet values)
{
var vars = CreateVariable(location, unit, name, false);
var res = AssignVariableWorker(location, unit, values, vars);
if (OuterScope != null)
{
var outerVar = OuterScope.GetVariable(location, unit, name, false);
if (outerVar != null && outerVar != vars)
{
OuterScope.AssignVariable(name, location, unit, values);
}
}
return(res);
}
public void ProcessAccessibilitySpecs(ast.ExprNodeIdentifier target, string identifier, Bookmark bmk)
{
// Check accessibility specs
for (int i = m_AccessibilitySpecs.Count - 1; i >= 0; i--)
{
var spec = m_AccessibilitySpecs[i];
if (spec.IsWildcard() && spec.DoesMatch(target, identifier))
{
var symbol=Members.DefineSymbol(identifier, bmk);
if (symbol.Accessibility == Accessibility.Default)
symbol.Accessibility = spec.GetAccessibility();
return;
}
}
// Pass to outer scope
if (OuterScope!=null)
OuterScope.ProcessAccessibilitySpecs(target, identifier, bmk);
}
public override ElementScope FillInWith(string value, Options options = null)
{
_element.FillInWith(value, Merge(options));
var list = OuterScope.FindXPath(listXPath, new Options()
{
Timeout = TimeSpan.FromSeconds(30)
});
if (!list.Exists(Merge(options)))
{
throw new Exception("Autocomplete list has not been found.");
}
else
{
Console.WriteLine(list.Text);
}
list.FindAllXPath(elementsXPath).Where(x => x.Text == value).First().Click(Merge(options));
return(this);
}
static void Main()
{
List <Action> actions = new List <Action>();
for (int i = 0; i < 5; i++)
{
OuterScope outer = new OuterScope();
outer.copyOfI = i;
for (int j = 0; j < 5; j++)
{
InnerScope inner = new InnerScope();
inner.outer = outer;
inner.copyOfJ = j;
actions.Add(inner.Action);
}
}
foreach (Action action in actions)
{
action();
}
}
public override IAnalysisSet AddNodeValue(Node node, IAnalysisSet variable)
{
return(OuterScope.AddNodeValue(node, variable));
}
internal override bool RemoveNodeScope(Node node) => OuterScope.RemoveNodeScope(node);
internal override void ClearNodeScopes() => OuterScope.ClearNodeScopes();
public override InterpreterScope AddNodeScope(Node node, InterpreterScope scope) => OuterScope.AddNodeScope(node, scope);
public override IAnalysisSet AddNodeValue(Node node, NodeValueKind kind, IAnalysisSet variable) => OuterScope.AddNodeValue(node, kind, variable);
internal override bool RemoveVariable(string name)
{
return(OuterScope.RemoveVariable(name));
}
public override VariableDef AddVariable(string name, VariableDef variable = null)
{
return(OuterScope.AddVariable(name, variable));
}
internal override bool RemoveVariable(string name) => OuterScope.RemoveVariable(name);
public override IEnumerable <KeyValuePair <string, VariableDef> > GetAllMergedVariables() => base.GetAllMergedVariables().Concat(OuterScope.GetAllMergedVariables());
public override VariableDef GetVariable(Node node, AnalysisUnit unit, string name, bool addRef = true) => base.GetVariable(node, unit, name, addRef) ?? OuterScope.GetVariable(node, unit, name, addRef);
public override InterpreterScope AddNodeScope(Node node, InterpreterScope scope)
{
return(OuterScope.AddNodeScope(node, scope));
}
static void PrintValues(ref OuterScope outer, ref InnerScope inner)
{
Console.WriteLine($"hour = {outer.hour}; minute = {inner.minute}");
}
public override IEnumerable <VariableDef> GetMergedVariables(string name)
{
return(base.GetMergedVariables(name).Concat(OuterScope.GetMergedVariables(name)));
}
public override IEnumerable <IVariableDefinition> GetMergedVariables(string name) => base.GetMergedVariables(name).Concat(OuterScope.GetMergedVariables(name));
internal override bool RemoveNodeValue(Node node)
{
return(OuterScope.RemoveNodeValue(node));
}
public override VariableDef AddVariable(string name, VariableDef variable = null) => OuterScope.AddVariable(name, variable);
internal override void ClearNodeValues()
{
OuterScope.ClearNodeValues();
}
internal override void ClearVariables() => OuterScope.ClearVariables();
// Forward variable handling to the outer scope.
public override VariableDef CreateVariable(Node node, AnalysisUnit unit, string name, bool addRef = true)
{
return(OuterScope.CreateVariable(node, unit, name, addRef));
}
