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