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)); }