internal virtual void AnalyzeWorker(DDG ddg, CancellationToken cancel)
{
ddg.SetCurrentUnit(this);
Ast.Walk(ddg);
List <KeyValuePair <string, VariableDef> > toRemove = null;
foreach (var variableInfo in DeclaringModule.Scope.AllVariables)
{
variableInfo.Value.ClearOldValues(ProjectEntry);
if (!variableInfo.Value.HasTypes && !variableInfo.Value.IsAssigned && !variableInfo.Value.IsEphemeral)
{
toRemove = toRemove ?? new List <KeyValuePair <string, VariableDef> >();
toRemove.Add(variableInfo);
}
}
if (toRemove != null)
{
// Do not allow variable removal to re-enqueue our unit
_suppressEnqueue = true;
try {
foreach (var nameValue in toRemove)
{
DeclaringModule.Scope.RemoveVariable(nameValue.Key);
// if anyone read this value it could now be gone (e.g. user
// deletes a class definition) so anyone dependent upon it
// needs to be updated.
nameValue.Value.EnqueueDependents();
}
} finally {
_suppressEnqueue = false;
}
}
}
internal virtual void AnalyzeWorker(DDG ddg, CancellationToken cancel)
{
DeclaringModule.Scope.ClearLinkedVariables();
ddg.SetCurrentUnit(this);
Ast.Walk(ddg);
List <KeyValuePair <string, VariableDef> > toRemove = null;
foreach (var variableInfo in DeclaringModule.Scope.AllVariables)
{
variableInfo.Value.ClearOldValues(ProjectEntry);
if (variableInfo.Value._dependencies.Count == 0 &&
!variableInfo.Value.HasTypes)
{
if (toRemove == null)
{
toRemove = new List <KeyValuePair <string, VariableDef> >();
}
toRemove.Add(variableInfo);
}
}
if (toRemove != null)
{
foreach (var nameValue in toRemove)
{
DeclaringModule.Scope.RemoveVariable(nameValue.Key);
// if anyone read this value it could now be gone (e.g. user
// deletes a class definition) so anyone dependent upon it
// needs to be updated.
nameValue.Value.EnqueueDependents();
}
}
}
internal override void AnalyzeWorker(DDG ddg, CancellationToken cancel)
{
InterpreterScope scope;
if (!ddg.Scope.TryGetNodeScope(Ast, out scope))
{
return;
}
var classInfo = ((ClassScope)scope).Class;
var bases = new List <IAnalysisSet>();
if (Ast.BasesInternal.Length == 0)
{
if (ddg.ProjectState.LanguageVersion.Is3x())
{
// 3.x all classes inherit from object by default
bases.Add(ddg.ProjectState.ClassInfos[BuiltinTypeId.Object]);
}
}
else
{
// Process base classes
for (int i = 0; i < Ast.BasesInternal.Length; i++)
{
var baseClassArg = Ast.BasesInternal[i];
if (baseClassArg.Name == null)
{
bases.Add(EvaluateBaseClass(ddg, classInfo, i, baseClassArg.Expression));
}
else if (baseClassArg.Name == "metaclass")
{
var metaClass = baseClassArg.Expression;
metaClass.Walk(ddg);
var metaClassValue = ddg._eval.Evaluate(metaClass);
if (metaClassValue.Count > 0)
{
classInfo.GetOrCreateMetaclassVariable().AddTypes(_outerUnit, metaClassValue);
}
}
}
}
classInfo.SetBases(bases);
foreach (var baseSet in bases)
{
foreach (var baseClassInfo in baseSet.OfType <ClassInfo>())
{
baseClassInfo._mro.AddDependency(this);
}
}
ddg.SetCurrentUnit(this);
ddg.WalkBody(Ast.Body, classInfo.AnalysisUnit);
}
internal virtual void AnalyzeWorker(DDG ddg, CancellationToken cancel)
{
Debug.Assert(ddg != null, "ddg unexpected null value");
Debug.Assert(Ast != null, "Ast has unexpected null value");
Debug.Assert(ProjectEntry != null, "ProjectEntry has unexpected null value");
Debug.Assert(DeclaringModuleEnvironment != null, "DeclaringModuleEnvironment has unexpected null value");
Debug.Assert(DeclaringModuleEnvironment.GlobalEnvironment != null, "DeclaringModuleEnvironment.GlobalEnvironment has unexpected null value");
Debug.Assert(DeclaringModuleEnvironment.Variables != null, "DeclaringModuleEnvironment.Variables has unexpected null value");
if (ddg == null || Ast == null || ProjectEntry == null || Tree != ProjectEntry.Tree || DeclaringModuleEnvironment?.Variables == null || DeclaringModuleEnvironment?.GlobalEnvironment == null)
{
// analysis unit properties are invalid or we were enqueued and a new version became available
// don't re-analyze against the old version.
return;
}
DeclaringModuleEnvironment.ClearLinkedVariables();
ddg.SetCurrentUnit(this);
Ast.Walk(ddg);
var toRemove = new List <KeyValuePair <string, VariableDef> >();
foreach (var variableInfo in DeclaringModuleEnvironment.Variables)
{
var value = variableInfo.Value;
if (value == null)
{
continue;
}
value.ClearOldValues(ProjectEntry);
if (value._dependencies.Count == 0 && value.TypesNoCopy.Count == 0)
{
toRemove.Add(variableInfo);
}
}
foreach (var nameValue in toRemove)
{
var globalEnvironment = DeclaringModuleEnvironment.GlobalEnvironment;
if (globalEnvironment != null)
{
globalEnvironment.RemoveVariable(nameValue.Key);
}
// if anyone read this value it could now be gone (e.g. user
// deletes a class definition) so anyone dependent upon it
// needs to be updated.
nameValue.Value?.EnqueueDependents();
}
}
internal override void AnalyzeWorker(DDG ddg, CancellationToken cancel)
{
ddg.SetCurrentUnit(this);
InterpreterScope scope;
if (!ddg.Scope.TryGetNodeScope(Ast, out scope))
{
return;
}
var classInfo = ((ClassScope)scope).Class;
var bases = ClassAnalysisUnit.EvaluateBaseClass(
ddg,
classInfo,
_indexInBasesList,
_baseClassNode
);
classInfo.SetBase(_indexInBasesList, bases);
_outerUnit.Enqueue();
}
internal virtual void AnalyzeWorker(DDG ddg, CancellationToken cancel)
{
if (Tree != ProjectEntry.Tree)
{
// we were enqueued and a new version became available, don't re-analyze against
// the old version.
return;
}
DeclaringModuleEnvironment.ClearLinkedVariables();
ddg.SetCurrentUnit(this);
Ast.Walk(ddg);
var toRemove = new List <KeyValuePair <string, VariableDef> >();
foreach (var variableInfo in DeclaringModuleEnvironment.Variables)
{
variableInfo.Value.ClearOldValues(ProjectEntry);
if (variableInfo.Value._dependencies.Count == 0 &&
variableInfo.Value.TypesNoCopy.Count == 0)
{
toRemove.Add(variableInfo);
}
}
foreach (var nameValue in toRemove)
{
DeclaringModuleEnvironment.GlobalEnvironment.RemoveVariable(nameValue.Key);
// if anyone read this value it could now be gone (e.g. user
// deletes a class definition) so anyone dependent upon it
// needs to be updated.
nameValue.Value.EnqueueDependents();
}
}
