public OverviewWalker(ProjectEntry entry, AnalysisUnit topAnalysis) { _entry = entry; _curUnit = topAnalysis; _scope = topAnalysis.Scope; }
internal bool AddTypes(Node node, AnalysisUnit unit, IAnalysisSet key, IAnalysisSet value, bool enqueue = true) { if (_keysAndValues.AddTypes(unit, key, value, enqueue)) { if (_keysVariable != null) { _keysVariable.MakeUnionStrongerIfMoreThan(ProjectState.Limits.DictKeyTypes, value); if (_keysVariable.AddTypes(unit, key, enqueue)) { if (_keysIter != null) { _keysIter.UnionType = null; } if (_keysList != null) { _keysList.UnionType = null; } } } if (_valuesVariable != null) { _valuesVariable.MakeUnionStrongerIfMoreThan(ProjectState.Limits.DictValueTypes, value); if (_valuesVariable.AddTypes(unit, value, enqueue)) { if (_valuesIter != null) { _valuesIter.UnionType = null; } if (_valuesList != null) { _valuesList.UnionType = null; } } } if (_keyValueTuple != null) { _keyValueTuple.IndexTypes[0].MakeUnionStrongerIfMoreThan(ProjectState.Limits.DictKeyTypes, key); _keyValueTuple.IndexTypes[1].MakeUnionStrongerIfMoreThan(ProjectState.Limits.DictValueTypes, value); _keyValueTuple.IndexTypes[0].AddTypes(unit, key, enqueue); _keyValueTuple.IndexTypes[1].AddTypes(unit, value, enqueue); } return true; } return false; }
public override INamespaceSet Call(Node node, AnalysisUnit unit, INamespaceSet[] args, NameExpression[] keywordArgNames) { if (args.Length == 0) { return unit.Scope.GetOrMakeNodeValue(node, n => new IteratorInfo(_indexTypes, _iterClass, n)); } return NamespaceSet.Empty; }
public override IAnalysisSet Call(Node node, AnalysisUnit unit, IAnalysisSet[] args, NameExpression[] keywordArgNames) { var res = AnalysisSet.Empty; foreach (var member in _members) { res = res.Union(member.Call(node, unit, args, keywordArgNames)); } return res; }
public override IAnalysisSet Call(Node node, AnalysisUnit unit, IAnalysisSet[] args, NameExpression[] keywordArgNames) { if (args.Length == 1) { var res = unit.Scope.GetOrMakeNodeValue( node, (node_) => MakeFromIndexes(node_, unit.ProjectEntry) ) as SequenceInfo; List<IAnalysisSet> seqTypes = new List<IAnalysisSet>(); foreach (var type in args[0]) { SequenceInfo seqInfo = type as SequenceInfo; if (seqInfo != null) { for (int i = 0; i < seqInfo.IndexTypes.Length; i++) { if (seqTypes.Count == i) { seqTypes.Add(seqInfo.IndexTypes[i].Types); } else { seqTypes[i] = seqTypes[i].Union(seqInfo.IndexTypes[i].Types); } } } else { var defaultIndexType = type.GetIndex(node, unit, ProjectState.GetConstant(0)); if (seqTypes.Count == 0) { seqTypes.Add(defaultIndexType); } else { seqTypes[0] = seqTypes[0].Union(defaultIndexType); } } } res.AddTypes(unit, seqTypes.ToArray()); return res; } return base.Call(node, unit, args, keywordArgNames); }
public override IAnalysisSet BinaryOperation(Node node, AnalysisUnit unit, PythonOperator operation, IAnalysisSet rhs) { IAnalysisSet res; switch (operation) { case PythonOperator.BitwiseOr: var seq = (SetInfo)unit.Scope.GetOrMakeNodeValue( node, _ => new SetInfo(ProjectState, node, unit.ProjectEntry) ); seq.AddTypes(unit, GetEnumeratorTypes(node, unit)); foreach (var type in rhs.Where(t => t.IsOfType(ClassInfo))) { seq.AddTypes(unit, type.GetEnumeratorTypes(node, unit)); } res = seq; break; case PythonOperator.BitwiseAnd: case PythonOperator.ExclusiveOr: case PythonOperator.Subtract: res = this; break; default: res = CallReverseBinaryOp(node, unit, operation, rhs); break; } return res; }
public override ISet<Namespace> Call(Node node, AnalysisUnit unit, ISet<Namespace>[] args) { _generator.Callers.AddDependency(unit); _generator.AddReturn(node, unit, base.Call(node, unit, args, keywordArgNames)); return _generator.SelfSet; }
private static IAnalysisSet CloneSpecializationImpl(FunctionValue func, Node node, AnalysisUnit unit, IAnalysisSet @this, IAnalysisSet[] args) { if (args.Length > 0) { return args[0]; } return AnalysisSet.Empty; }
public override IAnalysisSet Construct(Node node, AnalysisUnit unit, IAnalysisSet[] args) { var result = Call(node, unit, _instance.Proxy, args); if (result.Count != 0) { // function returned a value, we want to return any values // which are typed to object. foreach (var resultValue in result) { if (!resultValue.Value.IsObject) { // we need to do some filtering var tmpRes = AnalysisSet.Empty; foreach (var resultValue2 in result) { if (resultValue2.Value.IsObject) { tmpRes = tmpRes.Add(resultValue2); } } result = tmpRes; break; } } if (result.Count != 0) { return result; } } // we didn't return a value or returned a non-object // value. The result is our newly created instance object. return _instance.Proxy; }
public override INamespaceSet GetMember(Node node, AnalysisUnit unit, string name) { if (unit.ProjectState.LanguageVersion.Is6x() && name == "next" || unit.ProjectState.LanguageVersion.Is7x() && name == "__next__") { if (_next == null) { var next = this._type.GetMember(unit.ProjectEntry.MyScope.InterpreterContext, name); if (next != null) { _next = new NextBoundMethod((BuiltinMethodInfo)unit.ProjectState.GetNamespaceFromObjects(next), this); } } if (_next != null) { return _next.SelfSet; } } else if (name == "__iter__") { if (_iter == null) { var iter = this._type.GetMember(unit.ProjectEntry.MyScope.InterpreterContext, name); if (iter != null) { _iter = new IterBoundBuiltinMethodInfo((BuiltinMethodInfo)unit.ProjectState.GetNamespaceFromObjects(iter), this); } } if (_iter != null) { return _iter.SelfSet; } } return base.GetMember(node, unit, name); }
public FunctionAnalysisUnit(FunctionAnalysisUnit originalUnit, CallChain callChain, ArgumentSet callArgs) : base(originalUnit.Ast, null) { _originalUnit = originalUnit; _declUnit = originalUnit._declUnit; Function = originalUnit.Function; CallChain = callChain; var scope = new FunctionScope( Function, Ast, originalUnit.Scope.OuterScope, originalUnit.DeclaringModule.ProjectEntry ); scope.UpdateParameters(this, callArgs, false, originalUnit.Scope as FunctionScope); _scope = scope; var walker = new OverviewWalker(_originalUnit.ProjectEntry, this, Tree); if (Ast.Body != null) { Ast.Body.Walk(walker); } AnalysisLog.NewUnit(this); Enqueue(); }
public override IAnalysisSet Call(Node node, AnalysisUnit unit, IAnalysisSet[] args, NameExpression[] keywordArgNames) { if (_original == null) { return base.Call(node, unit, args, keywordArgNames); } return _original.Call(node, unit, args, keywordArgNames); }
public override IAnalysisSet BinaryOperation(Node node, AnalysisUnit unit, Parsing.PythonOperator operation, IAnalysisSet rhs) { var res = AnalysisSet.Empty; switch (operation) { case PythonOperator.Add: foreach (var type in rhs) { if (type.IsOfType(ClassInfo)) { res = res.Union(ClassInfo.Instance); } else { res = res.Union(type.ReverseBinaryOperation(node, unit, operation, SelfSet)); } } break; case PythonOperator.Mod: if (_supportsMod) { res = SelfSet; } break; case PythonOperator.Multiply: foreach (var type in rhs) { if (type.IsOfType(ProjectState.ClassInfos[BuiltinTypeId.Int]) || type.IsOfType(ProjectState.ClassInfos[BuiltinTypeId.Long])) { res = res.Union(ClassInfo.Instance); } else { var partialRes = ConstantInfo.NumericOp(node, this, unit, operation, rhs); if (partialRes != null) { res = res.Union(partialRes); } } } break; } return res ?? base.BinaryOperation(node, unit, operation, rhs); }
public override IAnalysisSet GetMember(Node node, AnalysisUnit unit, string name) { // Must unconditionally call the base implementation of GetMember var res = base.GetMember(node, unit, name); switch (name) { case "append": return _appendMethod = _appendMethod ?? new SpecializedCallable( res.OfType<BuiltinNamespace<IPythonType>>().FirstOrDefault(), ListAppend, false ); case "pop": return _popMethod = _popMethod ?? new SpecializedCallable( res.OfType<BuiltinNamespace<IPythonType>>().FirstOrDefault(), ListPop, false ); case "insert": return _insertMethod = _insertMethod ?? new SpecializedCallable( res.OfType<BuiltinNamespace<IPythonType>>().FirstOrDefault(), ListInsert, false ); case "extend": return _extendMethod = _extendMethod ?? new SpecializedCallable( res.OfType<BuiltinNamespace<IPythonType>>().FirstOrDefault(), ListExtend, false ); } return res; }
public override IAnalysisSet BinaryOperation(Node node, AnalysisUnit unit, Parsing.PythonOperator operation, IAnalysisSet rhs) { if (_original == null) { return base.BinaryOperation(node, unit, operation, rhs); } return _original.BinaryOperation(node, unit, operation, rhs); }
private IAnalysisSet ListInsert(Node node, AnalysisUnit unit, IAnalysisSet[] args, NameExpression[] keywordArgNames) { if (args.Length == 2) { AppendItem(node, unit, args[1]); } return unit.ProjectState._noneInst; }
/// <summary> /// Performs a delete index operation propagating the index types into /// the provided object. /// </summary> public static void DeleteMember(this IAnalysisSet self, Node node, AnalysisUnit unit, string name) { if (name != null && name.Length > 0) { foreach (var ns in self) { ns.DeleteMember(node, unit, name); } } }
public override IAnalysisSet Call(Node node, AnalysisUnit unit, IAnalysisSet[] args, NameExpression[] keywordArgNames) { var res = (DictionaryInfo)unit.Scope.GetOrMakeNodeValue( node, NodeValueKind.Dictionary, (node_) => new DictionaryInfo(unit.ProjectEntry, node) ); if (keywordArgNames.Length > 0) { for (int i = 0; i < keywordArgNames.Length; i++) { var curName = keywordArgNames[i].Name; var curArg = args[args.Length - keywordArgNames.Length + i]; if (curName == "**") { foreach (var value in curArg) { CopyFrom(args, res); } } else if (curName != "*") { res.AddTypes( node, unit, ProjectState.GetConstant(curName), curArg ); } } } else if (args.Length == 1) { foreach (var value in args[0]) { CopyFrom(args, res); } } return res; }
public override INamespaceSet GetMember(Node node, AnalysisUnit unit, string name) { switch (name) { case "append": EnsureAppend(); if (_appendMethod != null) { return _appendMethod.SelfSet; } break; case "pop": EnsurePop(); if (_popMethod != null) { return _popMethod.SelfSet; } break; case "insert": EnsureInsert(); if (_insertMethod != null) { return _insertMethod.SelfSet; } break; case "extend": EnsureExtend(); if (_extendMethod != null) { return _extendMethod.SelfSet; } break; } return base.GetMember(node, unit, name); }
public override INamespaceSet BinaryOperation(Node node, AnalysisUnit unit, JOperator operation, INamespaceSet rhs) { switch (operation) { case JOperator.GreaterThan: case JOperator.LessThan: case JOperator.LessThanOrEqual: case JOperator.GreaterThanOrEqual: case JOperator.Equal: case JOperator.NotEqual: case JOperator.Is: case JOperator.IsNot: return ProjectState._boolType.Instance; case JOperator.TrueDivide: case JOperator.Add: case JOperator.Subtract: case JOperator.Multiply: case JOperator.Divide: case JOperator.Mod: case JOperator.BitwiseAnd: case JOperator.BitwiseOr: case JOperator.Xor: case JOperator.LeftShift: case JOperator.RightShift: case JOperator.Power: case JOperator.FloorDivide: return ConstantInfo.NumericOp(node, this, unit, operation, rhs) ?? base.BinaryOperation(node, unit, operation, rhs); } return base.BinaryOperation(node, unit, operation, rhs); }
public override IAnalysisSet GetIndex(Node node, AnalysisUnit unit, IAnalysisSet index) { var res = base.GetIndex(node, unit, index); var names = index.OfType<ConstantInfo>() .Select(ci => ci.GetConstantValueAsString()) .Where(s => !string.IsNullOrEmpty(s)) .Distinct() .ToArray(); if (names.Length != 1) { // Unless you request a specific module by string literal, // you won't get any object out of sys.modules. return AnalysisSet.Empty; } var name = names[0]; lock (_owner.Modules) { IAnalysisSet knownValues; if (_owner.Modules.TryGetValue(name, out knownValues) && knownValues != null && knownValues.Any() ) { return knownValues; } } ModuleReference modRef; if (unit.ProjectState.Modules.TryImport(name, out modRef)) { return modRef.AnalysisModule; } return AnalysisSet.Empty; }
public override IAnalysisSet BinaryOperation(Node node, AnalysisUnit unit, PythonOperator operation, IAnalysisSet rhs) { switch (operation) { case PythonOperator.GreaterThan: case PythonOperator.LessThan: case PythonOperator.LessThanOrEqual: case PythonOperator.GreaterThanOrEqual: case PythonOperator.Equal: case PythonOperator.NotEqual: case PythonOperator.Is: case PythonOperator.IsNot: return ProjectState.ClassInfos[BuiltinTypeId.Bool].Instance; case PythonOperator.TrueDivide: case PythonOperator.Add: case PythonOperator.Subtract: case PythonOperator.Multiply: case PythonOperator.MatMultiply: case PythonOperator.Divide: case PythonOperator.Mod: case PythonOperator.BitwiseAnd: case PythonOperator.BitwiseOr: case PythonOperator.Xor: case PythonOperator.LeftShift: case PythonOperator.RightShift: case PythonOperator.Power: case PythonOperator.FloorDivide: return ConstantInfo.NumericOp(node, this, unit, operation, rhs) ?? CallReverseBinaryOp(node, unit, operation, rhs); } return CallReverseBinaryOp(node, unit, operation, rhs); }
/// <summary> /// Performs a SetMember operation for the given name and propagates the /// given values types for the provided member name. /// </summary> public static void SetMember(this IAnalysisSet self, Node node, AnalysisUnit unit, string name, IAnalysisSet value) { if (name != null && name.Length > 0) { foreach (var ns in self) { ns.Value.SetMember(node, unit, name, value); } } }
internal static BuiltinClassInfo GetIteratorTypeFromType(BuiltinClassInfo klass, AnalysisUnit unit) { switch (klass.PythonType.TypeId) { case BuiltinTypeId.List: return unit.ProjectState.ClassInfos[BuiltinTypeId.ListIterator]; case BuiltinTypeId.Tuple: return unit.ProjectState.ClassInfos[BuiltinTypeId.TupleIterator]; case BuiltinTypeId.Set: return unit.ProjectState.ClassInfos[BuiltinTypeId.SetIterator]; case BuiltinTypeId.Str: return unit.ProjectState.ClassInfos[BuiltinTypeId.StrIterator]; case BuiltinTypeId.Unicode: return unit.ProjectState.ClassInfos[BuiltinTypeId.UnicodeIterator]; case BuiltinTypeId.Bytes: return unit.ProjectState.ClassInfos[BuiltinTypeId.BytesIterator]; case BuiltinTypeId.Generator: case BuiltinTypeId.DictKeys: case BuiltinTypeId.DictValues: case BuiltinTypeId.DictItems: case BuiltinTypeId.ListIterator: case BuiltinTypeId.TupleIterator: case BuiltinTypeId.SetIterator: case BuiltinTypeId.StrIterator: case BuiltinTypeId.UnicodeIterator: case BuiltinTypeId.BytesIterator: case BuiltinTypeId.CallableIterator: return klass; default: return null; } }
public override IAnalysisSet BinaryOperation(Node node, AnalysisUnit unit, PythonOperator operation, IAnalysisSet rhs) { var res = AnalysisSet.Empty; foreach (var member in _members) { res = res.Union(member.BinaryOperation(node, unit, operation, rhs)); } return res; }
public override IAnalysisSet GetMember(Node node, AnalysisUnit unit, string name) { // Must unconditionally call the base implementation of GetMember var res = base.GetMember(node, unit, name); switch(name) { case "next": if (unit.ProjectState.LanguageVersion.Is2x()) { return _nextMethod = _nextMethod ?? new SpecializedCallable( res.OfType<BuiltinNamespace<IPythonType>>().FirstOrDefault(), GeneratorNext, false ); } break; case "__next__": if (unit.ProjectState.LanguageVersion.Is3x()) { return _nextMethod = _nextMethod ?? new SpecializedCallable( res.OfType<BuiltinNamespace<IPythonType>>().FirstOrDefault(), GeneratorNext, false ); } break; case "send": return _sendMethod = _sendMethod ?? new SpecializedCallable( res.OfType<BuiltinNamespace<IPythonType>>().FirstOrDefault(), GeneratorSend, false ); } return res; }
public OverviewWalker(ProjectEntry entry, AnalysisUnit topAnalysis, JsAst tree, bool isNested = false) { _entry = entry; _curUnit = topAnalysis; _isNested = isNested; _tree = tree; _scope = topAnalysis.Environment; }
public override INamespaceSet Call(Node node, AnalysisUnit unit, INamespaceSet[] args, NameExpression[] keywordArgNames) { if (args.Length == 2) { _list.AppendItem(node, unit, args[1]); } return ProjectState._noneInst.SelfSet; }
internal override void AddReference(Node node, AnalysisUnit analysisUnit) { if (_original == null) { base.AddReference(node, analysisUnit); return; } _original.AddReference(node, analysisUnit); }
public override void AugmentAssign(AugmentedAssignStatement node, AnalysisUnit unit, IAnalysisSet value) { if (_original == null) { base.AugmentAssign(node, unit, value); return; } _original.AugmentAssign(node, unit, value); }
public override IAnalysisSet GetEnumeratorTypes(Node node, AnalysisUnit unit) { return(ProjectState.ClassInfos[BuiltinTypeId.Int].Instance); }
public override VariableDef GetVariable(Node node, AnalysisUnit unit, string name, bool addRef = true) { return(base.GetVariable(node, unit, name, addRef) ?? OuterScope.GetVariable(node, unit, name, addRef)); }
/// <summary> /// Creates a new ExpressionEvaluator that will evaluate in the context of the top-level module. /// </summary> public ExpressionEvaluator(AnalysisUnit unit) { _unit = unit; Scope = unit.Scope; }
public override ISet <Namespace> Call(Node node, AnalysisUnit unit, ISet <Namespace>[] args, string[] keywordArgNames) { return(_generator.Yields); }
public override IAnalysisSet Call(Node node, AnalysisUnit unit, IAnalysisSet[] args, NameExpression[] keywordArgNames) { var callArgs = ArgumentSet.FromArgs(FunctionDefinition, unit, args, keywordArgNames); FunctionAnalysisUnit calledUnit; bool updateArguments = true; if (callArgs.Count == 0 || (ProjectState.Limits.UnifyCallsToNew && Name == "__new__") || _callDepthLimit == 0) { calledUnit = (FunctionAnalysisUnit)AnalysisUnit; } else if (FunctionDefinition.ReturnAnnotation != null) { // TODO: Reevaluate return annotation in context of arguments calledUnit = (FunctionAnalysisUnit)AnalysisUnit; } else { if (_allCalls == null) { _allCalls = new CallChainSet(); } var chain = new CallChain(node, unit, _callDepthLimit); var aggregate = GetAggregate(unit); if (!_allCalls.TryGetValue(aggregate, chain, _callDepthLimit, out calledUnit)) { if (unit.ForEval) { // Call expressions that weren't analyzed get the union result // of all calls to this function. var res = AnalysisSet.Empty; foreach (var call in _allCalls.Values) { res = res.Union(call.ReturnValue.GetTypesNoCopy(unit, DeclaringModule)); } return(res); } else { _callsSinceLimitChange += 1; if (_callsSinceLimitChange >= ProjectState.Limits.DecreaseCallDepth && _callDepthLimit > 1) { _callDepthLimit -= 1; _callsSinceLimitChange = 0; AnalysisLog.ReduceCallDepth(this, _allCalls.Count, _callDepthLimit); _allCalls.Clear(); chain = chain.Trim(_callDepthLimit); } calledUnit = new CalledFunctionAnalysisUnit(aggregate, (FunctionAnalysisUnit)AnalysisUnit, chain, callArgs); _allCalls.Add(aggregate, chain, calledUnit); updateArguments = false; } } } if (updateArguments && calledUnit.UpdateParameters(callArgs)) { AnalysisLog.UpdateUnit(calledUnit); } if (keywordArgNames != null && keywordArgNames.Any()) { calledUnit.AddNamedParameterReferences(unit, keywordArgNames); } calledUnit.ReturnValue.AddDependency(unit); return(calledUnit.ReturnValue.Types); }
public override IAnalysisSet GetTypeMember(Node node, AnalysisUnit unit, string name) { return(GetMemberNoReferences(node, unit, name).GetDescriptor(node, unit.ProjectState._noneInst, this, unit)); }
public override IAnalysisSet GetDescriptor(Node node, AnalysisValue instance, AnalysisValue context, AnalysisUnit unit) { if ((instance == ProjectState._noneInst && !IsClassMethod) || IsStatic) { return(SelfSet); } if (_methods == null) { _methods = new Dictionary <AnalysisValue, IAnalysisSet>(); } IAnalysisSet result; if (!_methods.TryGetValue(instance, out result) || result == null) { if (IsClassMethod) { _methods[instance] = result = new BoundMethodInfo(this, context).SelfSet; } else { _methods[instance] = result = new BoundMethodInfo(this, instance).SelfSet; } } if (IsProperty) { return(result.Call(node, unit, ExpressionEvaluator.EmptySets, ExpressionEvaluator.EmptyNames)); } return(result); }
public override IAnalysisSet GetIterator(Node node, AnalysisUnit unit) { return(SelfSet); }
internal ModuleAnalysis(AnalysisUnit unit, Stack <ScopePositionInfo> tree) { _unit = unit; _scopes = unit.Scopes; _scopeTree = tree; }
internal virtual void AddReference(Node node, AnalysisUnit analysisUnit) { }
public override IAnalysisSet GetTypeMember(Node node, AnalysisUnit unit, string name) { return(ProjectState.ClassInfos[BuiltinTypeId.Function].GetMember(node, unit, name)); }
public void SetCurrentUnit(AnalysisUnit unit) { _eval = new ExpressionEvaluator(unit); _unit = unit; }
public IAnalysisSet GetMemberNoReferences(Node node, AnalysisUnit unit, string name, bool addRef = true) { return(GetMemberFromMroNoReferences(this, node, unit, name, addRef)); }
internal void AddParameterReference(Node node, AnalysisUnit unit, string name) { var vd = (_analysisUnit.Scope as FunctionScope)?.GetParameter(name); vd?.AddReference(node, unit); }
internal void SetAnalysisUnit(AnalysisUnit unit) { Debug.Assert(_analysisUnit == null); _analysisUnit = unit; }
private IAnalysisSet DoCall(Node node, AnalysisUnit callingUnit, FunctionAnalysisUnit calledUnit, ArgumentSet callArgs) { calledUnit.UpdateParameters(callArgs); calledUnit.ReturnValue.AddDependency(callingUnit); return(calledUnit.ReturnValue.Types); }
// 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)); }
private IAnalysisSet CreateNamedTuple(Node node, AnalysisUnit unit, IAnalysisSet namedTupleName, IAnalysisSet namedTupleArgs) { var args = namedTupleArgs == null ? null : TypingTypeInfo.ToTypeList(namedTupleArgs); var res = new ProtocolInfo(unit.ProjectEntry, unit.State); string name; var description = new List <KeyValuePair <string, string> >(); if (args != null && args.Any()) { var tupleItem = new List <IAnalysisSet>(); foreach (var a in args) { // each arg is going to be either a union containing a string literal and type, // or a list with string literal and type. IAnalysisSet nameSet = a, valueSet = a; if (a is TypingTypeInfo tti) { var list = tti.ToTypeList(); if (list != null && list.Count >= 2) { nameSet = list[0]; valueSet = AnalysisSet.UnionAll(list.Skip(1)); } } if (!nameSet.Split(out IReadOnlyList <ConstantInfo> names, out var rest)) { names = a.OfType <ConstantInfo>().ToArray(); } name = names.Select(n => n.GetConstantValueAsString()).FirstOrDefault(n => !string.IsNullOrEmpty(n)) ?? "unnamed"; var p = new NamespaceProtocol(res, name); var value = ToInstance(valueSet); p.SetMember(node, unit, name, value); tupleItem.Add(value); res.AddProtocol(p); if (description.Any()) { description.Add(new KeyValuePair <string, string>(WellKnownRichDescriptionKinds.Comma, ", ")); } description.AddRange(p.GetRichDescription()); } res.AddProtocol(new TupleProtocol(res, tupleItem)); } name = namedTupleName?.GetConstantValueAsString().FirstOrDefault() ?? "tuple"; var np = new NameProtocol(res, name); if (description.Any()) { np.ExtendDescription(new KeyValuePair <string, string>(WellKnownRichDescriptionKinds.Misc, "(")); np.ExtendDescription(description); np.ExtendDescription(new KeyValuePair <string, string>(WellKnownRichDescriptionKinds.Misc, ")")); } res.AddProtocol(np); return(res); }
public TypingTypeInfoFinalizer(ExpressionEvaluator eval, Node node, AnalysisUnit unit) { _eval = eval; _node = node; _unit = unit; }
public void Imported(AnalysisUnit unit) { InterpreterModule.Imported(unit.DeclaringModule.InterpreterContext); unit.ProjectState.Modules.ImportChildren(InterpreterModule); }
public ExpressionEvaluator(AnalysisUnit unit, InterpreterScope scope, bool mergeScopes = false) { _unit = unit; Scope = scope; _mergeScopes = mergeScopes; }
public void AddDependency(AnalysisUnit unit) { Imported(unit); }
public bool AddDependentUnit(AnalysisUnit unit) { return(AddValue(ref _dependentUnits, unit)); }
/// <summary> /// Get the member by name, given the MRO list, and taking override rules into account. /// </summary> public static IAnalysisSet GetMemberFromMroNoReferences(IEnumerable <IAnalysisSet> mro, Node node, AnalysisUnit unit, string name, bool addRef = true) { if (mro == null) { return(AnalysisSet.Empty); } // Union all members within a single MRO entry, but stop at the first entry that yields a non-empty set since it overrides any that follow. var result = AnalysisSet.Empty; foreach (var mroEntry in mro) { foreach (var ns in mroEntry) { var classInfo = ns as ClassInfo; if (classInfo != null) { var v = classInfo.Scope.GetVariable(node, unit, name, addRef); if (v != null) { result = result.Union(v.Types); } } else { result = result.Union(ns.GetMember(node, unit, name)); } } if (result != null && result.Count > 0) { break; } } return(result); }
public virtual INamespaceSet GetDescriptor(Node node, Namespace instance, Namespace context, AnalysisUnit unit) { return(SelfSet); }
internal List <AnalysisValue> LookupBaseMethods(string name, IEnumerable <IAnalysisSet> bases, Node node, AnalysisUnit unit) { var result = new List <AnalysisValue>(); foreach (var b in bases) { foreach (var curType in b) { BuiltinClassInfo klass = curType as BuiltinClassInfo; if (klass != null) { var value = klass.GetMember(node, unit, name); if (value != null) { result.AddRange(value); } } } } return(result); }
internal static List <AnalysisValue> LookupBaseMethods(string name, IEnumerable <IAnalysisSet> mro, Node node, AnalysisUnit unit) { var result = new List <AnalysisValue>(); foreach (var @class in mro.Skip(1)) { foreach (var curType in @class) { bool isClass = curType is ClassInfo || curType is BuiltinClassInfo; if (isClass) { var value = curType.GetMember(node, unit, name); if (value != null) { result.AddRange(value); } } } } return(result); }
public virtual INamespaceSet GetStaticDescriptor(AnalysisUnit unit) { return(SelfSet); }
public void Analyze(Deque <AnalysisUnit> queue, CancellationToken cancel, Action <int> reportQueueSize = null, int reportQueueInterval = 1) { if (cancel.IsCancellationRequested) { return; } try { // Including a marker at the end of the queue allows us to see in // the log how frequently the queue empties. var endOfQueueMarker = new AnalysisUnit(null, null); int queueCountAtStart = queue.Count; int reportInterval = reportQueueInterval - 1; if (queueCountAtStart > 0) { queue.Append(endOfQueueMarker); } while (queue.Count > 0 && !cancel.IsCancellationRequested) { _unit = queue.PopLeft(); if (_unit == endOfQueueMarker) { AnalysisLog.EndOfQueue(queueCountAtStart, queue.Count); if (reportInterval < 0 && reportQueueSize != null) { reportQueueSize(queue.Count); } queueCountAtStart = queue.Count; if (queueCountAtStart > 0) { queue.Append(endOfQueueMarker); } continue; } AnalysisLog.Dequeue(queue, _unit); if (reportInterval == 0 && reportQueueSize != null) { reportQueueSize(queue.Count); reportInterval = reportQueueInterval - 1; } else if (reportInterval > 0) { reportInterval -= 1; } _unit.IsInQueue = false; SetCurrentUnit(_unit); AnalyzedEntries.Add(_unit.ProjectEntry); _unit.Analyze(this, cancel); } if (reportQueueSize != null) { reportQueueSize(0); } if (cancel.IsCancellationRequested) { AnalysisLog.Cancelled(queue); } } finally { AnalysisLog.Flush(); AnalyzedEntries.Remove(null); } }
public virtual void SetIndex(Node node, AnalysisUnit unit, INamespaceSet index, INamespaceSet value) { }