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(); }