internal ExpressionAnalysis(VsProjectAnalyzer analyzer, string expression, ModuleAnalysis analysis, int index, ITrackingSpan span, ITextSnapshot snapshot) {
_expr = expression;
_analysis = analysis;
_index = index;
_span = span;
_analyzer = analyzer;
_snapshot = snapshot;
}
private void Parse(bool enqueOnly)
{
if (_tree == null)
{
return;
}
var oldParent = _myScope.ParentPackage;
if (_filePath != null)
{
ProjectState.ModulesByFilename[_filePath] = _myScope;
}
if (oldParent != null)
{
// update us in our parent package
_myScope.ParentPackage = oldParent;
oldParent.Scope.SetVariable(_tree, _unit, _moduleName.Substring(_moduleName.IndexOf('.') + 1), _myScope.SelfSet, false);
}
var unit = _unit = new AnalysisUnit(_tree, new InterpreterScope[] { _myScope.Scope });
_scopeTree = new Stack <InterpreterScope>();
_scopeTree.Push(MyScope.Scope);
// create new analysis object and add to the queue to be analyzed
var newAnalysis = new ModuleAnalysis(_unit, _scopeTree);
_unit.Enqueue();
// collect top-level definitions first
var walker = new OverviewWalker(this, unit);
_tree.Walk(walker);
PublishPackageChildrenInPackage();
if (!enqueOnly)
{
((IGroupableAnalysisProject)_projectState).AnalyzeQueuedEntries();
}
// publish the analysis now that it's complete
_currentAnalysis = newAnalysis;
foreach (var variableInfo in _myScope.Scope.Variables)
{
variableInfo.Value.ClearOldValues(this);
}
}
private static IEnumerable<AnalysisValue> GetTestCaseClasses(ModuleAnalysis analysis) {
return analysis.GetAllAvailableMembersByIndex(0)
.SelectMany(m => analysis.GetValuesByIndex(m.Name, 0))
.Where(v => v.MemberType == PythonMemberType.Class)
.Where(v => v.Mro.SelectMany(v2 => v2).Any(IsTestCaseClass));
}
/// <summary>
/// Get Test Case Members for a class. If the class has 'test*' tests
/// return those. If there aren't any 'test*' tests return (if one at
/// all) the runTest overridden method
/// </summary>
private static IEnumerable<KeyValuePair<string, IAnalysisSet>> GetTestCaseMembers(
ModuleAnalysis analysis,
AnalysisValue classValue
) {
var methodFunctions = classValue.GetAllMembers(analysis.InterpreterContext)
.Where(v => v.Value.Any(m => m.MemberType == PythonMemberType.Function || m.MemberType == PythonMemberType.Method));
var tests = methodFunctions.Where(v => v.Key.StartsWith("test"));
var runTest = methodFunctions.Where(v => v.Key.Equals("runTest"));
if (tests.Any()) {
return tests;
} else {
return runTest;
}
}
internal static SourceLocation TranslateIndex(int index, ITextSnapshot fromSnapshot, ModuleAnalysis toAnalysisSnapshot) {
SnapshotCookie snapshotCookie;
// TODO: buffers differ in the REPL window case, in the future we should handle this better
if (toAnalysisSnapshot != null &&
fromSnapshot != null &&
(snapshotCookie = toAnalysisSnapshot.AnalysisCookie as SnapshotCookie) != null &&
snapshotCookie.Snapshot != null &&
snapshotCookie.Snapshot.TextBuffer == fromSnapshot.TextBuffer) {
var fromPoint = new SnapshotPoint(fromSnapshot, index);
var fromLine = fromPoint.GetContainingLine();
var toPoint = fromPoint.TranslateTo(snapshotCookie.Snapshot, PointTrackingMode.Negative);
var toLine = toPoint.GetContainingLine();
Debug.Assert(fromLine != null, "Unable to get 'from' line from " + fromPoint.ToString());
Debug.Assert(toLine != null, "Unable to get 'to' line from " + toPoint.ToString());
return new SourceLocation(
toPoint.Position,
(toLine != null ? toLine.LineNumber : fromLine != null ? fromLine.LineNumber : 0) + 1,
index - (fromLine != null ? fromLine.Start.Position : 0) + 1
);
} else if (fromSnapshot != null) {
var fromPoint = new SnapshotPoint(fromSnapshot, index);
var fromLine = fromPoint.GetContainingLine();
return new SourceLocation(
index,
fromLine.LineNumber + 1,
index - fromLine.Start.Position + 1
);
} else {
return new SourceLocation(index, 1, 1);
}
}
private void Parse(bool enqueueOnly, CancellationToken cancel)
{
PythonAst tree;
IAnalysisCookie cookie;
GetTreeAndCookie(out tree, out cookie);
if (tree == null) {
return;
}
var oldParent = _myScope.ParentPackage;
if (_filePath != null) {
ProjectState.ModulesByFilename[_filePath] = _myScope;
}
if (oldParent != null) {
// update us in our parent package
oldParent.AddChildPackage(_myScope, _unit);
} else if (_filePath != null) {
// we need to check and see if our parent is a package for the case where we're adding a new
// file but not re-analyzing our parent package.
string parentFilename;
if (ModulePath.IsInitPyFile(_filePath)) {
// subpackage
parentFilename = Path.Combine(Path.GetDirectoryName(Path.GetDirectoryName(_filePath)), "__init__.py");
} else {
// just a module
parentFilename = Path.Combine(Path.GetDirectoryName(_filePath), "__init__.py");
}
ModuleInfo parentPackage;
if (ProjectState.ModulesByFilename.TryGetValue(parentFilename, out parentPackage)) {
parentPackage.AddChildPackage(_myScope, _unit);
}
}
_unit = new AnalysisUnit(tree, _myScope.Scope);
AnalysisLog.NewUnit(_unit);
foreach (var value in MyScope.Scope.AllVariables) {
value.Value.EnqueueDependents();
}
MyScope.Scope.Children.Clear();
MyScope.Scope.ClearNodeScopes();
MyScope.Scope.ClearNodeValues();
MyScope.ClearUnresolvedModules();
// collect top-level definitions first
var walker = new OverviewWalker(this, _unit, tree);
tree.Walk(walker);
_myScope.Specialize();
// It may be that we have analyzed some child packages of this package already, but because it wasn't analyzed,
// the children were not registered. To handle this possibility, scan analyzed packages for children of this
// package (checked by module name first, then sanity-checked by path), and register any that match.
if (ModulePath.IsInitPyFile(_filePath)) {
string pathPrefix = Path.GetDirectoryName(_filePath) + "\\";
var children =
from pair in _projectState.ModulesByFilename
// Is the candidate child package in a subdirectory of our package?
let fileName = pair.Key
where fileName.StartsWith(pathPrefix)
let moduleName = pair.Value.Name
// Is the full name of the candidate child package qualified with the name of our package?
let lastDot = moduleName.LastIndexOf('.')
where lastDot > 0
let parentModuleName = moduleName.Substring(0, lastDot)
where parentModuleName == _myScope.Name
select pair.Value;
foreach (var child in children) {
_myScope.AddChildPackage(child, _unit);
}
}
_unit.Enqueue();
if (!enqueueOnly) {
_projectState.AnalyzeQueuedEntries(cancel);
}
// publish the analysis now that it's complete/running
_currentAnalysis = new ModuleAnalysis(
_unit,
((ModuleScope)_unit.Scope).CloneForPublish()
);
}
private void Parse(bool enqueueOnly, CancellationToken cancel)
{
PythonAst tree;
IAnalysisCookie cookie;
GetTreeAndCookie(out tree, out cookie);
if (tree == null)
{
return;
}
var oldParent = _myScope.ParentPackage;
if (_filePath != null)
{
ProjectState.ModulesByFilename[_filePath] = _myScope;
}
if (oldParent != null)
{
// update us in our parent package
oldParent.AddChildPackage(_myScope, _unit);
}
else if (_filePath != null)
{
// we need to check and see if our parent is a package for the case where we're adding a new
// file but not re-analyzing our parent package.
string parentFilename;
if (ModulePath.IsInitPyFile(_filePath))
{
// subpackage
parentFilename = Path.Combine(Path.GetDirectoryName(Path.GetDirectoryName(_filePath)), "__init__.py");
}
else
{
// just a module
parentFilename = Path.Combine(Path.GetDirectoryName(_filePath), "__init__.py");
}
ModuleInfo parentPackage;
if (ProjectState.ModulesByFilename.TryGetValue(parentFilename, out parentPackage))
{
parentPackage.AddChildPackage(_myScope, _unit);
}
}
_unit = new AnalysisUnit(tree, _myScope.Scope);
AnalysisLog.NewUnit(_unit);
foreach (var value in MyScope.Scope.AllVariables)
{
value.Value.EnqueueDependents();
}
MyScope.Scope.Children.Clear();
MyScope.Scope.ClearNodeScopes();
MyScope.Scope.ClearNodeValues();
MyScope.ClearUnresolvedModules();
// collect top-level definitions first
var walker = new OverviewWalker(this, _unit, tree);
tree.Walk(walker);
_myScope.Specialize();
// It may be that we have analyzed some child packages of this package already, but because it wasn't analyzed,
// the children were not registered. To handle this possibility, scan analyzed packages for children of this
// package (checked by module name first, then sanity-checked by path), and register any that match.
if (ModulePath.IsInitPyFile(_filePath))
{
string pathPrefix = Path.GetDirectoryName(_filePath) + "\\";
var children =
from pair in _projectState.ModulesByFilename
// Is the candidate child package in a subdirectory of our package?
let fileName = pair.Key
where fileName.StartsWith(pathPrefix)
let moduleName = pair.Value.Name
// Is the full name of the candidate child package qualified with the name of our package?
let lastDot = moduleName.LastIndexOf('.')
where lastDot > 0
let parentModuleName = moduleName.Substring(0, lastDot)
where parentModuleName == _myScope.Name
select pair.Value;
foreach (var child in children)
{
_myScope.AddChildPackage(child, _unit);
}
}
_unit.Enqueue();
if (!enqueueOnly)
{
_projectState.AnalyzeQueuedEntries(cancel);
}
// publish the analysis now that it's complete/running
_currentAnalysis = new ModuleAnalysis(
_unit,
((ModuleScope)_unit.Scope).CloneForPublish()
);
}
private void Parse(bool enqueueOnly, CancellationToken cancel)
{
#if DEBUG
Debug.Assert(Monitor.IsEntered(this));
#endif
var parse = GetCurrentParse();
var tree = parse?.Tree;
var cookie = parse?.Cookie;
if (tree == null)
{
return;
}
var oldParent = MyScope.ParentPackage;
if (FilePath != null)
{
ProjectState.ModulesByFilename[FilePath] = MyScope;
}
if (oldParent != null)
{
// update us in our parent package
oldParent.AddChildPackage(MyScope, _unit);
}
else if (FilePath != null)
{
// we need to check and see if our parent is a package for the case where we're adding a new
// file but not re-analyzing our parent package.
string parentFilename;
if (ModulePath.IsInitPyFile(FilePath))
{
// subpackage
parentFilename = Path.Combine(Path.GetDirectoryName(Path.GetDirectoryName(FilePath)), "__init__.py");
}
else
{
// just a module
parentFilename = Path.Combine(Path.GetDirectoryName(FilePath), "__init__.py");
}
if (ProjectState.ModulesByFilename.TryGetValue(parentFilename, out var parentPackage))
{
parentPackage.AddChildPackage(MyScope, _unit);
}
}
_unit = new AnalysisUnit(tree, MyScope.Scope);
AnalysisLog.NewUnit(_unit);
MyScope.Scope.Children = new List <InterpreterScope>();
MyScope.Scope.ClearNodeScopes();
MyScope.Scope.ClearNodeValues();
MyScope.Scope.ClearLinkedVariables();
MyScope.Scope.ClearVariables();
MyScope.ClearReferencedModules();
MyScope.ClearUnresolvedModules();
_unit.State.ClearDiagnostics(this);
MyScope.EnsureModuleVariables(_unit.State);
foreach (var value in MyScope.Scope.AllVariables)
{
value.Value.EnqueueDependents();
}
// collect top-level definitions first
var walker = new OverviewWalker(this, _unit, tree);
tree.Walk(walker);
MyScope.Specialize();
// It may be that we have analyzed some child packages of this package already, but because it wasn't analyzed,
// the children were not registered. To handle this possibility, scan analyzed packages for children of this
// package (checked by module name first, then sanity-checked by path), and register any that match.
if (ModulePath.IsInitPyFile(FilePath))
{
string pathPrefix = PathUtils.EnsureEndSeparator(Path.GetDirectoryName(FilePath));
var children =
from pair in ProjectState.ModulesByFilename
// Is the candidate child package in a subdirectory of our package?
let fileName = pair.Key
where fileName.StartsWithOrdinal(pathPrefix, ignoreCase: true)
let moduleName = pair.Value.Name
// Is the full name of the candidate child package qualified with the name of our package?
let lastDot = moduleName.LastIndexOf('.')
where lastDot > 0
let parentModuleName = moduleName.Substring(0, lastDot)
where parentModuleName == MyScope.Name
select pair.Value;
foreach (var child in children)
{
MyScope.AddChildPackage(child, _unit);
}
}
_unit.Enqueue();
if (!enqueueOnly)
{
ProjectState.AnalyzeQueuedEntries(cancel);
}
// publish the analysis now that it's complete/running
Analysis = new ModuleAnalysis(
_unit,
((ModuleScope)_unit.Scope).CloneForPublish(),
DocumentUri,
AnalysisVersion
);
}
public ClassifierWalker(PythonAst ast, ModuleAnalysis analysis, ITextSnapshot snapshot, Dictionary<string, IClassificationType> formatMap) {
_ast = ast;
_analysis = analysis;
_snapshot = snapshot;
_formatMap = formatMap;
Spans = new List<List<CachedClassification>>();
}
public ClassifierWalker(PythonAst ast, ModuleAnalysis analysis) {
_ast = ast;
_analysis = analysis;
Spans = new List<AP.AnalysisClassification>();
}