private object NewDo(NewAst ast)
{
var className = Resolve(ast);
var classType = (className as ClassSymbol).Src as ClassAst;
var space = new MemorySpace();
var oldSpace = MemorySpaces.Current;
MemorySpaces.Current = space;
foreach (var symbol in classType.Body.ScopedStatements)
{
Exec(symbol);
}
if (classType.Constructor != null)
{
var funcInvoke = new FuncInvoke(classType.Constructor.Token, ast.Args);
funcInvoke.CurrentScope = classType.Body.CurrentScope;
Exec(funcInvoke);
}
MemorySpaces.Current = oldSpace;
return(space);
}
private void ValidateClassConstructorArgs(NewAst ast, ClassSymbol classSource)
{
if (!ResolvingTypes)
{
return;
}
if (classSource == null)
{
throw new ArgumentException("classSource");
}
var constructor = GetConstructorForClass(classSource.Src as ClassAst);
if (constructor != null)
{
if (CollectionUtil.IsNullOrEmpty(ast.Args) && !CollectionUtil.IsNullOrEmpty(constructor.Arguments))
{
throw new InvalidSyntax("Not enough arguments for constructor arguments");
}
if (ast.Args.Count != constructor.Arguments.Count)
{
throw new InvalidSyntax("Not enough arguments for constructor arguments");
}
(classSource.Src as ClassAst).Constructor = constructor;
}
}
public void Visit(NewAst ast)
{
ast.Args.ForEach(arg => arg.Visit(this));
if (ResolvingTypes)
{
if (ast.Name.Token.TokenType == TokenType.Word && !ast.IsArray)
{
var className = Resolve(ast.Name) as ClassSymbol;
if (className == null)
{
className = ast.Global.Resolve(ast.Name) as ClassSymbol;
if (className == null)
{
throw new InvalidSyntax(String.Format("Class {0} is undefined", ast.Name.Token.TokenValue));
}
}
ValidateClassConstructorArgs(ast, className);
ast.AstSymbolType = className.Type;
}
else if (ast.IsArray)
{
}
else
{
throw new InvalidSyntax("Cannot new type of " + ast.Name);
}
}
SetScope(ast);
}
private void Parse(CancellationToken cancellationToken)
{
CollectingErrorSink sink = null;
int version;
Parser parser;
//Log?.Log(TraceEventType.Verbose, $"Parse begins: {Name}");
lock (AnalysisLock) {
version = _buffer.Version;
var options = new ParserOptions {
StubFile = FilePath != null && Path.GetExtension(FilePath).Equals(".pyi", FileSystem.StringComparison)
};
if (ModuleType == ModuleType.User)
{
sink = new CollectingErrorSink();
options.ErrorSink = sink;
}
parser = Parser.CreateParser(new StringReader(_buffer.Text), Interpreter.LanguageVersion, options);
}
var ast = parser.ParseFile();
//Log?.Log(TraceEventType.Verbose, $"Parse complete: {Name}");
lock (AnalysisLock) {
cancellationToken.ThrowIfCancellationRequested();
if (version != _buffer.Version)
{
throw new OperationCanceledException();
}
_ast = ast;
_parseErrors = sink?.Diagnostics ?? Array.Empty <DiagnosticsEntry>();
// Do not report issues with libraries or stubs
if (sink != null)
{
_diagnosticsService?.Replace(Uri, _parseErrors, DiagnosticSource.Parser);
}
ContentState = State.Parsed;
}
NewAst?.Invoke(this, EventArgs.Empty);
if (ContentState < State.Analyzing)
{
ContentState = State.Analyzing;
var analyzer = Services.GetService <IPythonAnalyzer>();
analyzer.EnqueueDocumentForAnalysis(this, ast, version, _disposeToken.CancellationToken);
}
lock (AnalysisLock) {
_parsingTask = null;
}
}
private void Parse(CancellationToken cancellationToken)
{
CollectingErrorSink sink = null;
int version;
Parser parser;
// Log?.Log(TraceEventType.Verbose, $"Parse begins: {Name} ({ModuleType})");
lock (_syncObj) {
version = _buffer.Version;
var options = new ParserOptions {
StubFile = FilePath != null && Path.GetExtension(FilePath).Equals(".pyi", FileSystem.StringComparison)
};
if (ModuleType == ModuleType.User)
{
sink = new CollectingErrorSink();
options.ErrorSink = sink;
}
parser = Parser.CreateParser(new StringReader(_buffer.Text), Interpreter.LanguageVersion, options);
}
var ast = parser.ParseFile(Uri);
// Log?.Log(TraceEventType.Verbose, $"Parse complete: {Name} ({ModuleType})");
lock (_syncObj) {
cancellationToken.ThrowIfCancellationRequested();
if (version != _buffer.Version)
{
throw new OperationCanceledException();
}
// Stored nodes are no longer valid.
_astMap.Clear();
_astMap[this] = ast;
_parseErrors = sink?.Diagnostics ?? Array.Empty <DiagnosticsEntry>();
// Do not report issues with libraries or stubs
if (sink != null)
{
_diagnosticsService?.Replace(Uri, _parseErrors, DiagnosticSource.Parser);
}
ContentState = State.Parsed;
Analysis = new EmptyAnalysis(Services, this);
}
NewAst?.Invoke(this, EventArgs.Empty);
Analyze(ast, version);
lock (_syncObj) {
_parsingTask = null;
}
}
private void Parse(CancellationToken cancellationToken)
{
var sink = new CollectingErrorSink();
int version;
Parser parser;
Log?.Log(TraceEventType.Verbose, $"Parse begins: {Name}");
lock (AnalysisLock) {
version = _buffer.Version;
parser = Parser.CreateParser(new StringReader(_buffer.Text), Interpreter.LanguageVersion, new ParserOptions {
StubFile = FilePath != null && Path.GetExtension(FilePath).Equals(".pyi", FileSystem.StringComparison),
ErrorSink = sink
});
}
var ast = parser.ParseFile();
Log?.Log(TraceEventType.Verbose, $"Parse complete: {Name}");
lock (AnalysisLock) {
cancellationToken.ThrowIfCancellationRequested();
if (version != _buffer.Version)
{
throw new OperationCanceledException();
}
_ast = ast;
_parseErrors = sink.Diagnostics;
_parsingTask = null;
}
NewAst?.Invoke(this, EventArgs.Empty);
if ((_options & ModuleLoadOptions.Analyze) == ModuleLoadOptions.Analyze)
{
Log?.Log(TraceEventType.Verbose, $"Analysis queued: {Name}");
_linkedAnalysisCts?.Dispose();
_linkedAnalysisCts = CancellationTokenSource.CreateLinkedTokenSource(_allProcessingCts.Token, cancellationToken);
var analyzer = Services.GetService <IPythonAnalyzer>();
if (ModuleType == ModuleType.User || ModuleType == ModuleType.Library)
{
analyzer.AnalyzeDocumentDependencyChainAsync(this, _linkedAnalysisCts.Token).DoNotWait();
}
else
{
analyzer.AnalyzeDocumentAsync(this, _linkedAnalysisCts.Token).DoNotWait();
}
}
}
public void Visit(NewAst ast)
{
Exec(ast);
}
public void Visit(NewAst ast)
{
throw new NotImplementedException();
}
