public FunctionScope(
FunctionInfo function,
Node node,
InterpreterScope declScope,
IPythonProjectEntry declModule
)
: base(function, node, declScope) {
ReturnValue = new VariableDef();
if (Function.FunctionDefinition.IsCoroutine) {
Coroutine = new CoroutineInfo(function.ProjectState, declModule);
ReturnValue.AddTypes(function.ProjectEntry, Coroutine.SelfSet, false);
} else if (Function.FunctionDefinition.IsGenerator) {
Generator = new GeneratorInfo(function.ProjectState, declModule);
ReturnValue.AddTypes(function.ProjectEntry, Generator.SelfSet, false);
}
}
public FunctionScope(FunctionInfo function, Node node, InterpreterScope declScope)
: base(function, node, declScope)
{
ReturnValue = new VariableDef();
if (Function.FunctionDefinition.IsGenerator) {
Generator = new GeneratorInfo(function.ProjectState, Function.FunctionDefinition);
ReturnValue.AddTypes(function.ProjectEntry, Generator.SelfSet, false);
}
}
private void PropagateIsInstanceTypes(Node node, AnalysisUnit unit, IAnalysisSet typeSet, VariableDef variable) {
foreach (var typeObj in typeSet) {
ClassInfo classInfo;
BuiltinClassInfo builtinClassInfo;
SequenceInfo seqInfo;
if ((classInfo = typeObj as ClassInfo) != null) {
variable.AddTypes(unit, classInfo.Instance, false);
} else if ((builtinClassInfo = typeObj as BuiltinClassInfo) != null) {
variable.AddTypes(unit, builtinClassInfo.Instance, false);
} else if ((seqInfo = typeObj as SequenceInfo) != null) {
if (seqInfo.Push()) {
try {
foreach (var indexVar in seqInfo.IndexTypes) {
PropagateIsInstanceTypes(node, unit, indexVar.Types, variable);
}
} finally {
seqInfo.Pop();
}
}
}
}
}
public override IAnalysisSet GetMember(Node node, AnalysisUnit unit, string name) {
var res = AnalysisSet.Empty;
if (name == "func") {
AddReference(node, unit);
return _function;
} else if (name == "args") {
AddReference(node, unit);
if (_argsTuple == null) {
_argsTuple = new SequenceInfo(_args.Take(_args.Length - _keywordArgNames.Length)
.Select(v => {
var vd = new VariableDef();
vd.AddTypes(unit, v, false, DeclaringModule);
return vd;
}).ToArray(),
unit.ProjectState.ClassInfos[BuiltinTypeId.Tuple],
node,
unit.ProjectEntry
);
}
return _argsTuple;
} else if (name == "keywords") {
AddReference(node, unit);
if (_keywordsDict == null) {
var dict = new DictionaryInfo(unit.ProjectEntry, node);
_keywordsDict = dict;
for (int i = 0; i < _keywordArgNames.Length; ++i) {
int j = i + _args.Length - _keywordArgNames.Length;
if (j >= 0 && j < _args.Length) {
dict._keysAndValues.AddTypes(
unit,
unit.ProjectState.GetConstant(_keywordArgNames[i].Name),
_args[j],
false
);
}
}
}
return _keywordsDict;
}
return res;
}
/// <summary>
/// Handles the base assignment case for assign to a variable, minus variable creation.
/// </summary>
protected static bool AssignVariableWorker(Node location, AnalysisUnit unit, IAnalysisSet values, VariableDef vars)
{
vars.AddAssignment(location, unit);
vars.MakeUnionStrongerIfMoreThan(unit.ProjectState.Limits.AssignedTypes, values);
return(vars.AddTypes(unit, values));
}
public override void SetMember(Node node, AnalysisUnit unit, string name, IAnalysisSet value)
{
_values.AddTypes(unit, value);
}
private static void SpecializeVariableDef(VariableDef def, CallDelegate callable, bool mergeOriginalAnalysis) {
List<AnalysisValue> items = new List<AnalysisValue>();
foreach (var v in def.TypesNoCopy) {
if (!(v is SpecializedNamespace) && v.DeclaringModule != null) {
items.Add(v);
}
}
def._dependencies = default(SingleDict<IVersioned, ReferenceableDependencyInfo>);
foreach (var item in items) {
def.AddTypes(item.DeclaringModule, new SpecializedCallable(item, callable, mergeOriginalAnalysis).SelfSet);
}
}
public void AddSend(Node node, AnalysisUnit unit, IAnalysisSet sendValue, bool enqueue = true)
{
Sends.AddTypes(unit, sendValue, enqueue);
}
public void AddReturn(Node node, AnalysisUnit unit, IAnalysisSet returnValue, bool enqueue = true)
{
Returns.MakeUnionStrongerIfMoreThan(ProjectState.Limits.ReturnTypes, returnValue);
Returns.AddTypes(unit, returnValue, enqueue);
}
public void AddYield(Node node, AnalysisUnit unit, IAnalysisSet yieldValue, bool enqueue = true)
{
Yields.MakeUnionStrongerIfMoreThan(ProjectState.Limits.YieldTypes, yieldValue);
Yields.AddTypes(unit, yieldValue, enqueue);
}
IAnalysisSet ReturnsListOfString(Node node, AnalysisUnit unit, IAnalysisSet[] args, NameExpression[] keywordArgNames) {
return unit.Scope.GetOrMakeNodeValue(node, n => {
var vars = new VariableDef();
vars.AddTypes(unit, unit.ProjectState.ClassInfos[BuiltinTypeId.Str].Instance);
return new ListInfo(
new[] { vars },
unit.ProjectState.ClassInfos[BuiltinTypeId.List],
node,
unit.ProjectEntry
);
});
}
/// <summary>
/// Handles the base assignment case for assign to a variable, minus variable creation.
/// </summary>
protected static bool AssignVariableWorker(Node location, AnalysisUnit unit, IAnalysisSet values, VariableDef vars) {
vars.AddAssignment(location, unit);
vars.MakeUnionStrongerIfMoreThan(unit.ProjectState.Limits.AssignedTypes, values);
return vars.AddTypes(unit, values);
}
private static void SpecializeVariableDef(Func<CallExpression, AnalysisUnit, INamespaceSet[], NameExpression[], INamespaceSet> dlg, VariableDef def, bool analyze)
{
List<Namespace> items = new List<Namespace>();
foreach (var v in def.TypesNoCopy) {
if (!(v is SpecializedNamespace) && v.DeclaringModule != null) {
items.Add(v);
}
}
def._dependencies = default(SingleDict<IProjectEntry, TypedDependencyInfo<Namespace>>);
foreach (var item in items) {
def.AddTypes(item.DeclaringModule, SpecializedCallable.MakeSpecializedCallable(dlg, analyze, item).SelfSet);
}
}
