public OverviewWalker(ProjectEntry entry, AnalysisUnit topAnalysis)
{
_entry = entry;
_curUnit = topAnalysis;
_scope = topAnalysis.Scope;
}
public override void PostWalk(GeneratorExpression node)
{
Debug.Assert(_scope is ComprehensionScope);
_scope = _scope.OuterScope;
base.PostWalk(node);
}
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);
}
}
public override void PostWalk(FunctionDefinition node)
{
if (node.Body != null && node.Name != null) {
Debug.Assert(_scope.Node == node);
Debug.Assert(_scope.OuterScope.Node != node);
_scope = _scope.OuterScope;
_curUnit = _analysisStack.Pop();
Debug.Assert(_scope.EnumerateTowardsGlobal.Contains(_curUnit.Scope));
}
}
internal FunctionInfo(FunctionDefinition node, AnalysisUnit declUnit, InterpreterScope declScope)
{
_projectEntry = declUnit.ProjectEntry;
_functionDefinition = node;
_declVersion = declUnit.ProjectEntry.AnalysisVersion;
if (Name == "__new__") {
IsClassMethod = true;
}
_analysisUnit = new FunctionAnalysisUnit(this, declUnit, declScope);
}
internal FunctionAnalysisUnit(FunctionInfo function, AnalysisUnit declUnit, InterpreterScope declScope)
: base(function.FunctionDefinition, null)
{
_declUnit = declUnit;
Function = function;
_decoratorCalls = new Dictionary<Node, Expression>();
var scope = new FunctionScope(Function, Function.FunctionDefinition, declScope);
scope.EnsureParameters(this, null);
_scope = scope;
AnalysisLog.NewUnit(this);
}
public InterpreterScope(Namespace ns, Node ast, InterpreterScope outerScope)
{
_ns = ns;
_node = ast;
OuterScope = outerScope;
_nodeScopes = new Dictionary<Node, InterpreterScope>();
_nodeValues = new Dictionary<Node, INamespaceSet>();
_variables = new Dictionary<string, VariableDef>();
#if DEBUG
NodeScopes = new ReadOnlyDictionary<Node, InterpreterScope>(_nodeScopes);
NodeValues = new ReadOnlyDictionary<Node, INamespaceSet>(_nodeValues);
Variables = new ReadOnlyDictionary<string, VariableDef>(_variables);
#endif
}
public virtual InterpreterScope AddNodeScope(Node node, InterpreterScope scope)
{
return _nodeScopes[node] = scope;
}
internal bool TryGetNodeScope(Node node, out InterpreterScope scope)
{
foreach (var s in EnumerateTowardsGlobal) {
if (s._nodeScopes.TryGetValue(node, out scope)) {
return true;
}
}
scope = null;
return false;
}
public ComprehensionScope(Namespace comprehensionResult, Comprehension comprehension, InterpreterScope outerScope)
: base(comprehensionResult, comprehension, outerScope)
{
}
public override InterpreterScope AddNodeScope(Node node, InterpreterScope scope)
{
return OuterScope.AddNodeScope(node, scope);
}
// TODO: What about names being redefined?
// remember classes/functions as they start new scopes
public override bool Walk(ClassDefinition node)
{
var cls = AddClass(node, _curUnit);
if (cls != null) {
_analysisStack.Push(_curUnit);
_curUnit = cls.AnalysisUnit;
Debug.Assert(_scope.EnumerateTowardsGlobal.Contains(cls.AnalysisUnit.Scope.OuterScope));
_scope = cls.AnalysisUnit.Scope;
return true;
}
return false;
}
public override void PostWalk(DictionaryComprehension node)
{
Debug.Assert(_scope is ComprehensionScope);
_scope = _scope.OuterScope;
base.PostWalk(node);
}
private void PushIsInstanceScope(Node node, KeyValuePair<NameExpression, Expression>[] isInstanceNames, SuiteStatement effectiveSuite)
{
InterpreterScope scope;
if (!_curUnit.Scope.TryGetNodeScope(node, out scope)) {
if (_scope is IsInstanceScope) {
// Reuse the current scope
_curUnit.Scope.AddNodeScope(node, _scope);
return;
}
// find our parent scope, it may not be just the last entry in _scopes
// because that can be a StatementScope and we would start a new range.
var declScope = _scope.EnumerateTowardsGlobal.FirstOrDefault(s => !(s is StatementScope));
scope = new IsInstanceScope(node.StartIndex, effectiveSuite, declScope);
declScope.Children.Add(scope);
declScope.AddNodeScope(node, scope);
_scope = scope;
}
}
public StatementScope(int index, InterpreterScope outerScope)
: base(null, outerScope)
{
_startIndex = _endIndex = index;
}
private IEnumerable<IAnalysisVariable> GetVariablesInScope(NameExpression name, InterpreterScope scope)
{
foreach (var res in scope.GetMergedVariables(name.Name).SelectMany(ToVariables)) {
yield return res;
}
// if a variable is imported from another module then also yield the defs/refs for the
// value in the defining module.
var linked = scope.GetLinkedVariablesNoCreate(name.Name);
if (linked != null) {
foreach (var linkedVar in linked) {
foreach (var res in ToVariables(linkedVar)) {
yield return res;
}
}
}
var classScope = scope as ClassScope;
if (classScope != null) {
// if the member is defined in a base class as well include the base class member and references
var cls = classScope.Class;
if (cls.Push()) {
try {
foreach (var baseNs in cls.Bases.SelectMany(c => c)) {
if (baseNs.Push()) {
try {
ClassInfo baseClassNs = baseNs as ClassInfo;
if (baseClassNs != null) {
foreach (var res in baseClassNs.Scope.GetMergedVariables(name.Name).SelectMany(ToVariables)) {
yield return res;
}
}
} finally {
baseNs.Pop();
}
}
}
} finally {
cls.Pop();
}
}
}
}
/// <summary>
/// Makes sure we create a scope for a comprehension (generator, set, dict, or list comprehension in 3.x) where
/// the variables which are assigned will be stored.
/// </summary>
private void EnsureComprehensionScope(Comprehension node, Func<Comprehension, ComprehensionScope> makeScope)
{
InterpreterScope scope, declScope = _scope;
if (!declScope.TryGetNodeScope(node, out scope)) {
scope = makeScope(node);
declScope.AddNodeScope(node, scope);
declScope.Children.Add(scope);
}
_scope = scope;
}
internal static FunctionInfo AddFunction(FunctionDefinition node, AnalysisUnit outerUnit, InterpreterScope prevScope)
{
InterpreterScope scope;
if (!prevScope.TryGetNodeScope(node, out scope)) {
if (node.Body == null || node.Name == null) {
return null;
}
var func = new FunctionInfo(node, outerUnit, prevScope);
var unit = func.AnalysisUnit;
scope = unit.Scope;
prevScope.Children.Add(scope);
prevScope.AddNodeScope(node, scope);
if (!node.IsLambda && node.Name != "<genexpr>") {
// lambdas don't have their names published
var funcVar = prevScope.AddLocatedVariable(node.Name, node.NameExpression, unit);
// Decorated functions don't have their type set yet
if (node.Decorators == null) {
funcVar.AddTypes(unit, func.SelfSet);
}
}
unit.Enqueue();
}
return scope.Namespace as FunctionInfo;
}
public override bool Walk(SuiteStatement node)
{
var prevSuite = _curSuite;
_curSuite = node;
// recursively walk the statements in the suite
if (node.Statements != null) {
foreach (var innerNode in node.Statements) {
innerNode.Walk(this);
}
}
_curSuite = prevSuite;
// then check if we encountered an assert which added an isinstance scope.
IsInstanceScope isInstanceScope = _scope as IsInstanceScope;
if (isInstanceScope != null && isInstanceScope._effectiveSuite == node) {
// pop the isinstance scope
_scope = _scope.OuterScope;
var declScope = _curUnit.Scope;
// transform back into a line number and start the new statement scope on the line
// after the suite statement.
var lineNo = _entry.Tree.IndexToLocation(node.EndIndex).Line;
int offset;
if (_entry.Tree._lineLocations.Length == 0) {
// single line input
offset = 0;
} else {
offset = lineNo < _entry.Tree._lineLocations.Length ? _entry.Tree._lineLocations[lineNo] : _entry.Tree._lineLocations[_entry.Tree._lineLocations.Length - 1];
}
var closingScope = new StatementScope(offset, declScope);
_scope = closingScope;
declScope.Children.Add(closingScope);
}
return false;
}
public override bool Walk(FunctionDefinition node)
{
var function = AddFunction(node, _curUnit);
if (function != null) {
_analysisStack.Push(_curUnit);
_curUnit = function.AnalysisUnit;
Debug.Assert(_scope.EnumerateTowardsGlobal.Contains(function.AnalysisUnit.Scope.OuterScope));
_scope = function.AnalysisUnit.Scope;
return true;
}
return false;
}
public InterpreterScope(Namespace ns, InterpreterScope outerScope)
: this(ns, null, outerScope)
{
}
INamespaceSet IModule.GetModuleMember(Node node, AnalysisUnit unit, string name, bool addRef, InterpreterScope linkedScope, string linkedName)
{
var res = NamespaceSet.Empty;
foreach (var member in _members.OfType<IModule>()) {
res = res.Union(member.GetModuleMember(node, unit, name, addRef, linkedScope, linkedName));
}
return res;
}
/// <summary>
/// Finds the best available analysis unit for lookup. This will be the one that is provided
/// by the nearest enclosing scope that is capable of providing one.
/// </summary>
private AnalysisUnit GetNearestEnclosingAnalysisUnit(InterpreterScope scopes)
{
var units = from scope in scopes.EnumerateTowardsGlobal
let ns = scope.Namespace
where ns != null
let unit = ns.AnalysisUnit
where unit != null
select unit;
return units.FirstOrDefault() ?? _unit;
}
public override void PostWalk(SuiteStatement node)
{
while (_scope is StatementScope) {
_scope = _scope.OuterScope;
}
base.PostWalk(node);
}
public IsInstanceScope(int startIndex, SuiteStatement effectiveSuite, InterpreterScope outerScope)
: base(null, null, outerScope)
{
_startIndex = _endIndex = startIndex;
_effectiveSuite = effectiveSuite;
}
private IEnumerable<MemberResult> GetKeywordMembers(GetMemberOptions options, InterpreterScope scope)
{
if (options.ExpressionKeywords()) {
// keywords available in any context
yield return new MemberResult("and", JMemberType.Keyword);
yield return new MemberResult("as", JMemberType.Keyword);
yield return new MemberResult("else", JMemberType.Keyword);
yield return new MemberResult("for", JMemberType.Keyword);
yield return new MemberResult("if", JMemberType.Keyword);
yield return new MemberResult("in", JMemberType.Keyword);
yield return new MemberResult("is", JMemberType.Keyword);
yield return new MemberResult("lambda", JMemberType.Keyword);
yield return new MemberResult("not", JMemberType.Keyword);
yield return new MemberResult("or", JMemberType.Keyword);
}
bool isStmtContext = options.StatementKeywords();
// and now the keywords...
if (scope is FunctionScope) {
if (isStmtContext) {
yield return new MemberResult("return", JMemberType.Keyword);
}
// yield is always available as an expression in 2.5+
yield return new MemberResult("yield", JMemberType.Keyword);
}
if (isStmtContext) {
// statement context only
yield return new MemberResult("assert", JMemberType.Keyword);
yield return new MemberResult("break", JMemberType.Keyword);
yield return new MemberResult("continue", JMemberType.Keyword);
yield return new MemberResult("class", JMemberType.Keyword);
yield return new MemberResult("def", JMemberType.Keyword);
yield return new MemberResult("del", JMemberType.Keyword);
yield return new MemberResult("elif", JMemberType.Keyword);
yield return new MemberResult("except", JMemberType.Keyword);
yield return new MemberResult("finally", JMemberType.Keyword);
yield return new MemberResult("from", JMemberType.Keyword);
yield return new MemberResult("global", JMemberType.Keyword);
yield return new MemberResult("import", JMemberType.Keyword);
yield return new MemberResult("pass", JMemberType.Keyword);
yield return new MemberResult("raise", JMemberType.Keyword);
yield return new MemberResult("try", JMemberType.Keyword);
yield return new MemberResult("while", JMemberType.Keyword);
yield return new MemberResult("with", JMemberType.Keyword);
}
if (ProjectState.LanguageVersion.Is7x()) {
yield return new MemberResult("False", JMemberType.Keyword);
yield return new MemberResult("None", JMemberType.Keyword);
yield return new MemberResult("True", JMemberType.Keyword);
// statement context only
if (isStmtContext) {
yield return new MemberResult("nonlocal", JMemberType.Keyword);
}
}
if (ProjectState.LanguageVersion.Is6x() && isStmtContext) {
// statement context only
yield return new MemberResult("exec", JMemberType.Keyword);
yield return new MemberResult("print", JMemberType.Keyword);
}
}
public override void PostWalk(ListComprehension node)
{
if (_curUnit.ProjectState.LanguageVersion.Is7x()) {
Debug.Assert(_scope is ComprehensionScope);
_scope = _scope.OuterScope;
}
base.PostWalk(node);
}
public ClassScope(ClassInfo classInfo, ClassDefinition ast, InterpreterScope outerScope)
: base(classInfo, ast, outerScope)
{
classInfo.Scope = this;
}
// Returns False if no more parameters can be updated for this unit.
private bool UpdateSingleDefaultParameter(AnalysisUnit unit, InterpreterScope scope, int index, IParameterInfo info)
{
if (index >= FunctionDefinition.Parameters.Count) {
return false;
}
VariableDef param;
var name = FunctionDefinition.Parameters[index].Name;
if (scope.Variables.TryGetValue(name, out param)) {
var ns = ProjectState.GetNamespaceFromObjects(info.ParameterType);
if ((info.IsParamArray && !(param is ListParameterVariableDef)) ||
(info.IsKeywordDict && !(param is DictParameterVariableDef))) {
return false;
}
param.AddTypes(unit, ns);
}
return true;
}
private static bool IsFirstLineOfFunction(InterpreterScope innerScope, InterpreterScope outerScope, int index)
{
if (innerScope.OuterScope == outerScope && innerScope is FunctionScope) {
var funcScope = (FunctionScope)innerScope;
var def = funcScope.Function.FunctionDefinition;
// TODO: Use indexes rather than lines to check location
int lineNo = def.GlobalParent.IndexToLocation(index).Line;
if (lineNo == def.GetStart(def.GlobalParent).Line) {
return true;
}
}
return false;
}