internal JScriptException(JSError errorNumber, IndexSpan span, LocationResolver resolver) { m_valueObject = null; _span = span; _resolver = resolver; m_errorCode = errorNumber; SetHResult(); }
public SourceSpan GetTokenSpan(IndexSpan span) { return(new SourceSpan( NewLineLocation.IndexToLocation(TokenNewlines, span.Start), NewLineLocation.IndexToLocation(TokenNewlines, span.End) )); }
public GenericTypeParameter(string name, IPythonModule declaringModule, IReadOnlyList <IPythonType> constraints, IPythonType bound, string documentation, IndexSpan location) : base(name, new Location(declaringModule), documentation) { Constraints = constraints ?? Array.Empty <IPythonType>(); Bound = bound; }
public override IMember Create(ModuleFactory mf, IPythonType declaringType, IGlobalScope gs) { if (_cls != null) { return(_cls); } _cls = new PythonClassType(Name, new Location(mf.Module, IndexSpan.ToSpan())); var bases = CreateBases(mf, gs); _cls.SetBases(bases); _cls.SetDocumentation(Documentation); if (GenericParameterValues.Length > 0) { _cls.StoreGenericParameters( _cls, _cls.GenericParameters.Keys.ToArray(), GenericParameterValues.ToDictionary( k => _cls.GenericParameters.Keys.First(x => x == k.Name), v => mf.ConstructType(v.Type) ) ); } var all = Classes.Concat <MemberModel>(Properties).Concat(Methods).Concat(Fields); foreach (var m in all) { _cls.AddMember(m.Name, m.Create(mf, _cls, gs), false); } return(_cls); }
public static Expression CombineWithComma(IndexSpan span, JSParser parser, Expression operand1, Expression operand2) { var comma = new CommaOperator(parser.EncodeSpan(span)); List<Expression> res = new List<Expression>(); CommaOperator left = operand1 as CommaOperator; CommaOperator right = operand2 as CommaOperator; if (left != null) { res.AddRange(left.Expressions); } else { res.Add(operand1); } if (right != null) { res.AddRange(right.Expressions); } else { res.Add(operand2); } comma.Expressions = res.ToArray(); return comma; }
private static void CheckAndReadNext(Tokenizer tokenizer, IndexSpan tokenSpan, TokenKind tokenKind) { var token = tokenizer.GetNextToken(); tokenizer.TokenSpan.Should().Be(tokenSpan); token.Kind.Should().Be(tokenKind); }
private SourceSpan GetTokenSpan(IndexSpan span) { EnsureTokens(); return(new SourceSpan( NewLineLocation.IndexToLocation(_tokenNewlines, span.Start), NewLineLocation.IndexToLocation(_tokenNewlines, span.End) )); }
public override bool Walk(ObjectLiteral node) { if (_typedChar == '}' && node.GetEndIndex(_tree.LocationResolver) == _position) { Span = node.GetSpan(_tree.LocationResolver); return(false); } return(base.Walk(node)); }
public override bool Walk(Block block) { if (CheckBlock(block)) { Span = GetTargetStatement(block).GetSpan(_tree.LocationResolver); return(false); } return(true); }
public override bool Walk(WithNode node) { if (CheckBlock(node.Body)) { Span = GetTargetStatement(node).GetSpan(_tree.LocationResolver); return(false); } return(base.Walk(node)); }
public override bool Walk(Switch node) { if (_typedChar == '}' && node.GetEndIndex(_tree.LocationResolver) == _position) { Span = GetTargetStatement(node).GetSpan(_tree.LocationResolver); return(false); } return(base.Walk(node)); }
public TokenExt(Token token, string precedingWhitespace, IndexSpan span, int line, bool isMultiLine, TokenExt prev) { Token = token; PrecedingWhitespace = precedingWhitespace; Span = span; Line = line; Prev = prev; IsMultilineString = IsString && isMultiLine; }
private static bool ShouldIncludeStatementKeywords(Node statement, int index, out IndexSpan?span) { span = null; if (statement == null) { return(true); } // Always allow keywords in non-keyword statements if (statement is ExpressionStatement) { return(true); } // Allow keywords at start of assignment, but not in subsequent names if (statement is AssignmentStatement ss) { var firstAssign = ss.Left?.FirstOrDefault(); return(firstAssign == null || index <= firstAssign.EndIndex); } // Allow keywords when we are in another keyword if (statement is Statement s && index <= s.KeywordEndIndex) { int keywordStart = s.KeywordEndIndex - s.KeywordLength; if (index >= keywordStart) { span = new IndexSpan(keywordStart, s.KeywordLength); } else if ((s as IMaybeAsyncStatement)?.IsAsync == true) { // Must be in the "async" at the start of the keyword span = new IndexSpan(s.StartIndex, "async".Length); } return(true); } // TryStatementHandler is 'except', but not a Statement subclass if (statement is TryStatementHandler except && index <= except.KeywordEndIndex) { int keywordStart = except.KeywordEndIndex - except.KeywordLength; if (index >= keywordStart) { span = new IndexSpan(keywordStart, except.KeywordLength); } return(true); } // Allow keywords in function body (we'd have a different statement if we were deeper) if (statement is FunctionDefinition fd && index >= fd.HeaderIndex) { return(true); } // Allow keywords within with blocks, but not in their definition if (statement is WithStatement ws) { return(index >= ws.HeaderIndex || index <= ws.KeywordEndIndex); } return(false); }
private static void PopSpan( Stack <Tuple <int, string> > spanStartStack, IDictionary <string, List <IndexSpan> > spans, int finalIndex) { var spanStartTuple = spanStartStack.Pop(); var span = IndexSpan.FromBounds(spanStartTuple.Item1, finalIndex); GetOrAdd(spans, spanStartTuple.Item2, _ => new List <IndexSpan>()).Add(span); }
private void CheckStatement(Statement node) { if (_typedChar == ';' && node.GetEndIndex(_tree.LocationResolver) == _position) { // if(1)if(1)if(1)if(1)x+=2; // We want to reformat all of the if statements that are nested // so walk up the parent nodes as long as they are all terminated // at the same semicolon. Span = GetTargetStatement(node).GetSpan(_tree.LocationResolver); } }
public override bool Walk(TryNode node) { if (CheckBlock(node.TryBlock) || CheckBlock(node.FinallyBlock) || CheckBlock(node.CatchBlock)) { Span = GetTargetStatement(node).GetSpan(_tree.LocationResolver); return(false); } return(base.Walk(node)); }
public override IMember Create(ModuleFactory mf, IPythonType declaringType, IGlobalScope gs) { if (_namedTuple != null) { return(_namedTuple); } var itemTypes = ItemTypes.Select(mf.ConstructType).ToArray(); _namedTuple = new NamedTupleType(Name, ItemNames, itemTypes, mf.Module, IndexSpan.ToSpan()); return(_namedTuple); }
internal void HandleError(JSError errorId, IndexSpan span, LocationResolver resolver, bool forceToError = false) { var error = new JScriptException(errorId, span, resolver); if (forceToError) { error.IsError = true; } else { error.IsError = error.Severity < 2; } if (!OnCompilerError(error)) { } }
public GenericTypeParameter( string name, IPythonModule declaringModule, IReadOnlyList <IPythonType> constraints, IPythonType bound, object covariant, object contravariant, IndexSpan indexSpan) : base(name, new Location(declaringModule, indexSpan), GetDocumentation(name, constraints, bound, covariant, contravariant, declaringModule)) { Constraints = constraints ?? Array.Empty <IPythonType>(); Bound = bound; Covariant = covariant; Contravariant = contravariant; }
public string GetSignatureString(IPythonFunctionType ft, IPythonType self, out IndexSpan[] parameterSpans, int overloadIndex = 0, string name = null) { var o = ft.Overloads[overloadIndex]; var parameterStrings = GetFunctionParameters(ft, out var parameterNameLengths); var returnDoc = o.GetReturnDocumentation(self); var annString = string.IsNullOrEmpty(returnDoc) ? string.Empty : $" -> {returnDoc}"; // Calculate parameter spans parameterSpans = new IndexSpan[parameterStrings.Length]; name = name ?? ft.Name; var offset = name.Length + 1; for (var i = 0; i < parameterStrings.Length; i++) { parameterSpans[i] = IndexSpan.FromBounds(offset, offset + parameterNameLengths[i]); offset += parameterStrings[i].Length + 2; // name,<space> } var combinedParameterString = string.Join(", ", parameterStrings); return($"{name}({combinedParameterString}){annString}"); }
internal void SetLoc(int start, int end) { _span = new IndexSpan(start, end >= start ? end - start : start); }
public override bool Walk(TryNode node) { if (CheckBlock(node.TryBlock) || CheckBlock(node.FinallyBlock) || CheckBlock(node.CatchBlock)) { Span = GetTargetStatement(node).GetSpan(_tree.LocationResolver); return false; } return base.Walk(node); }
public override bool Walk(ObjectLiteral node) { if (_typedChar == '}' && node.GetEndIndex(_tree.LocationResolver) == _position) { Span = node.GetSpan(_tree.LocationResolver); return false; } return base.Walk(node); }
public static IMember Next(IPythonModule module, IPythonFunctionOverload overload, IArgumentSet argSet, IndexSpan indexSpan) { var args = argSet.Values <IMember>(); return(args.Count > 0 && args[0] is IPythonIterator it ? it.Next : null); }
public static IMember GetAttr(IPythonModule module, IPythonFunctionOverload overload, IArgumentSet argSet, IndexSpan indexSpan) { // TODO: Try __getattr__ first; this may not be as reliable in practice // given we could be assuming that __getattr__ always returns the same type, // which is incorrect more often than not. var args = argSet.Values <IMember>(); if (args.Count < 2) { return(null); } var o = args[0]; var name = (args[1] as IPythonConstant)?.GetString(); IMember def = null; if (args.Count >= 3) { def = args[2]; } // second argument to getattr was not a string, which is a runtime error // getattr(a, 3.14) if (name == null) { // TODO diagnostic error when second arg of getattr is not a string return(module.Interpreter.UnknownType); } return(o?.GetPythonType().GetMember(name) ?? def); }
public TokenWithSpan(Token token, IndexSpan span) { _token = token; _span = span; }
internal void HandleUndeclaredVariable(string name, IndexSpan span, LocationResolver indexResolver) { if (!HasAlreadySeenErrorFor(name)) { HandleError(JSError.UndeclaredVariable, span, indexResolver); } }
public TokenWithSpan(Token token, IndexSpan span) { this.token = token; this.span = span; }
public ExpectedToken(TokenKind kind, IndexSpan span, string image) { Kind = kind; Span = span; Image = image; }
internal void SetLoc(IndexSpan span) { _span = span; }
public static IMember Open(IPythonModule declaringModule, IPythonFunctionOverload overload, IArgumentSet argSet, IndexSpan indexSpan) { var mode = argSet.GetArgumentValue <IPythonConstant>("mode"); var binary = false; var writable = false; var readWrite = false; var modeString = mode?.GetString(); if (modeString != null) { binary = modeString.Contains("b"); writable = modeString.Contains("w") || modeString.Contains("a") || modeString.Contains("x"); readWrite = writable && modeString.Contains("r"); } string returnTypeName; var io = declaringModule.Interpreter.ModuleResolution.GetImportedModule("io"); if (binary) { returnTypeName = writable ? readWrite ? "BufferedRandom" : "BufferedWriter" : "BufferedReader"; } else { returnTypeName = "TextIOWrapper"; } var returnType = io?.GetMember(returnTypeName)?.GetPythonType(); return(returnType != null?returnType.CreateInstance(argSet) : null); }
public static IMember Iterator(IPythonModule module, IPythonFunctionOverload overload, IArgumentSet argSet, IndexSpan indexSpan) { var args = argSet.Values <IMember>(); if (args.Count > 0) { if (args[0] is IPythonCollection seq) { return(seq.GetIterator()); } var t = args[0].GetPythonType(); if (t.IsBuiltin && t.Name == "str") { return(new PythonTypeIterator(BuiltinTypeId.StrIterator, BuiltinTypeId.Str, module.Interpreter)); } } return(null); }
public static IMember Identity(IPythonModule module, IPythonFunctionOverload overload, IArgumentSet argSet, IndexSpan indexSpan) { var args = argSet.Values <IMember>(); return(args.Count > 0 ? args.FirstOrDefault(a => !a.IsUnknown()) ?? args[0] : null); }
public static IMember ListOfStrings(IPythonModule module, IPythonFunctionOverload overload, IArgumentSet argSet, IndexSpan indexSpan) { var type = new TypingListType("List", module.Interpreter.GetBuiltinType(BuiltinTypeId.Str), module.Interpreter, false); return(new TypingList(type)); }
public static IMember List(IPythonInterpreter interpreter, IPythonFunctionOverload overload, IArgumentSet argSet, IndexSpan indexSpan) => PythonCollectionType.CreateList(interpreter.ModuleResolution.BuiltinsModule, argSet);
public static int CalculateIndices <TriangleOrderer>(TriangleOrderer orderer, byte config, int triangleIndex, IndexSpan tris, CellVertices bl, CellVertices br, CellVertices tr, CellVertices tl, NativeArray <int> triangles) where TriangleOrderer : struct, ITriangleOrderer { if (tris.length == 0) { return(triangleIndex); } switch (config) { // full case MaskBL | MaskBR | MaskTR | MaskTL: { orderer.AddTriangle(triangles, ref triangleIndex, Vertex(bl), Vertex(tl), Vertex(tr)); orderer.AddTriangle(triangles, ref triangleIndex, Vertex(bl), Vertex(tr), Vertex(br)); break; } // corners case MaskBL: { orderer.AddTriangle(triangles, ref triangleIndex, Vertex(bl), LeftEdge(bl), BottomEdge(bl)); break; } case MaskBR: { orderer.AddTriangle(triangles, ref triangleIndex, BottomEdge(bl), LeftEdge(br), Vertex(br)); break; } case MaskTR: { orderer.AddTriangle(triangles, ref triangleIndex, BottomEdge(tl), Vertex(tr), LeftEdge(br)); break; } case MaskTL: { orderer.AddTriangle(triangles, ref triangleIndex, Vertex(tl), BottomEdge(tl), LeftEdge(bl)); break; } // halves case MaskBL | MaskBR: { orderer.AddTriangle(triangles, ref triangleIndex, Vertex(bl), LeftEdge(bl), Vertex(br)); orderer.AddTriangle(triangles, ref triangleIndex, Vertex(br), LeftEdge(bl), LeftEdge(br)); break; } case MaskTL | MaskTR: { orderer.AddTriangle(triangles, ref triangleIndex, Vertex(tl), Vertex(tr), LeftEdge(bl)); orderer.AddTriangle(triangles, ref triangleIndex, LeftEdge(bl), Vertex(tr), LeftEdge(br)); break; } case MaskBL | MaskTL: { orderer.AddTriangle(triangles, ref triangleIndex, Vertex(bl), BottomEdge(tl), BottomEdge(bl)); orderer.AddTriangle(triangles, ref triangleIndex, Vertex(bl), Vertex(tl), BottomEdge(tl)); break; } case MaskBR | MaskTR: { orderer.AddTriangle(triangles, ref triangleIndex, BottomEdge(bl), Vertex(tr), Vertex(br)); orderer.AddTriangle(triangles, ref triangleIndex, BottomEdge(bl), BottomEdge(tl), Vertex(tr)); break; } // diagonals case MaskBL | MaskTR: { orderer.AddTriangle(triangles, ref triangleIndex, BottomEdge(bl), Vertex(bl), LeftEdge(bl)); orderer.AddTriangle(triangles, ref triangleIndex, BottomEdge(bl), LeftEdge(bl), LeftEdge(br)); orderer.AddTriangle(triangles, ref triangleIndex, LeftEdge(br), LeftEdge(bl), BottomEdge(tl)); orderer.AddTriangle(triangles, ref triangleIndex, BottomEdge(tl), Vertex(tr), LeftEdge(br)); break; } case MaskTL | MaskBR: { orderer.AddTriangle(triangles, ref triangleIndex, LeftEdge(bl), Vertex(tl), BottomEdge(tl)); orderer.AddTriangle(triangles, ref triangleIndex, LeftEdge(bl), BottomEdge(tl), BottomEdge(bl)); orderer.AddTriangle(triangles, ref triangleIndex, BottomEdge(bl), BottomEdge(tl), LeftEdge(br)); orderer.AddTriangle(triangles, ref triangleIndex, BottomEdge(bl), LeftEdge(br), Vertex(br)); break; } // three quarters case MaskBL | MaskTR | MaskBR: { orderer.AddTriangle(triangles, ref triangleIndex, Vertex(br), Vertex(bl), LeftEdge(bl)); orderer.AddTriangle(triangles, ref triangleIndex, Vertex(br), LeftEdge(bl), BottomEdge(tl)); orderer.AddTriangle(triangles, ref triangleIndex, Vertex(br), BottomEdge(tl), Vertex(tr)); break; } case MaskBL | MaskTL | MaskBR: { orderer.AddTriangle(triangles, ref triangleIndex, Vertex(bl), Vertex(tl), BottomEdge(tl)); orderer.AddTriangle(triangles, ref triangleIndex, Vertex(bl), BottomEdge(tl), LeftEdge(br)); orderer.AddTriangle(triangles, ref triangleIndex, Vertex(bl), LeftEdge(br), Vertex(br)); break; } case MaskBL | MaskTL | MaskTR: { orderer.AddTriangle(triangles, ref triangleIndex, Vertex(tl), BottomEdge(bl), Vertex(bl)); orderer.AddTriangle(triangles, ref triangleIndex, Vertex(tl), LeftEdge(br), BottomEdge(bl)); orderer.AddTriangle(triangles, ref triangleIndex, Vertex(tl), Vertex(tr), LeftEdge(br)); break; } case MaskTL | MaskTR | MaskBR: { orderer.AddTriangle(triangles, ref triangleIndex, Vertex(tr), LeftEdge(bl), Vertex(tl)); orderer.AddTriangle(triangles, ref triangleIndex, Vertex(tr), BottomEdge(bl), LeftEdge(bl)); orderer.AddTriangle(triangles, ref triangleIndex, Vertex(tr), Vertex(br), BottomEdge(bl)); break; } } return(triangleIndex); }
public static IMember DictStringToObject(IPythonModule module, IPythonFunctionOverload overload, IArgumentSet argSet, IndexSpan indexSpan) { var str = module.Interpreter.GetBuiltinType(BuiltinTypeId.Str); var obj = module.Interpreter.GetBuiltinType(BuiltinTypeId.Object); var type = new TypingDictionaryType("Dict", str, obj, module.Interpreter, false); return(new TypingDictionary(type)); }
public void SetLoc(PythonAst globalParent, IndexSpan span) { _span = span; _parent = globalParent; }
public static IMember Range(IPythonModule module, IPythonFunctionOverload overload, IArgumentSet argSet, IndexSpan indexSpan) { var args = argSet.Values <IMember>(); if (args.Count > 0) { var type = new PythonCollectionType(BuiltinTypeId.List, module.Interpreter.ModuleResolution.BuiltinsModule, false); return(new PythonCollection(type, new[] { args[0] })); } return(null); }
public override bool Walk(WithNode node) { if (CheckBlock(node.Body)) { Span = GetTargetStatement(node).GetSpan(_tree.LocationResolver); return false; } return base.Walk(node); }
public override bool Walk(Block block) { if (CheckBlock(block)) { Span = GetTargetStatement(block).GetSpan(_tree.LocationResolver); return false; } return true; }
public void SetLoc(PythonAst globalParent, int start, int end) { _span = new IndexSpan(start, end > start ? end - start : start); _parent = globalParent; }
public void SetLoc(TotemAst globalParent, IndexSpan span) { _span = span; _parent = globalParent; }
private IPythonType CreateNamedTuple(IReadOnlyList <IMember> typeArgs, IPythonModule declaringModule, IndexSpan indexSpan) { if (typeArgs.Count != 2) { // TODO: report wrong number of arguments return(Interpreter.UnknownType); } ; if (!typeArgs[0].TryGetConstant <string>(out var tupleName) || string.IsNullOrEmpty(tupleName)) { // TODO: report name is incorrect. return(Interpreter.UnknownType); } var argList = (typeArgs[1] as IPythonCollection)?.Contents; if (argList == null) { // TODO: report type spec is not a list. return(Interpreter.UnknownType); } var itemNames = new List <string>(); var itemTypes = new List <IPythonType>(); foreach (var a in argList) { if (a.TryGetConstant(out string itemName1)) { // Not annotated itemNames.Add(itemName1); itemTypes.Add(Interpreter.UnknownType); continue; } // Now assume annotated pair that comes as a tuple. if (!(a is IPythonCollection c) || c.Type.TypeId != BuiltinTypeId.Tuple) { // TODO: report that item is not a tuple. continue; } if (c.Contents.Count != 2) { // TODO: report extra items in the element spec. continue; } if (!c.Contents[0].TryGetConstant <string>(out var itemName2)) { // TODO: report item name is not a string. continue; } itemNames.Add(itemName2); itemTypes.Add(c.Contents[1].GetPythonType()); } return(TypingTypeFactory.CreateNamedTupleType(tupleName, itemNames, itemTypes, declaringModule, indexSpan)); }
private void ReportSyntaxError(Token t, IndexSpan span, int errorCode, bool allowIncomplete) { var start = span.Start; var end = span.End; if (allowIncomplete && t.Kind == TokenType.EndOfFile) { errorCode |= ErrorCodes.IncompleteStatement; } string msg = String.Format(CultureInfo.InvariantCulture, GetErrorMessage(t, errorCode), t.Image); ReportSyntaxError(start, end, msg, errorCode); }
private void ReportSyntaxError(Token t, IndexSpan span, int errorCode, bool allowIncomplete) { var start = span.Start; var end = span.End; if (allowIncomplete && (t.Kind == TokenKind.EndOfFile || (_tokenizer.IsEndOfFile && t.Kind == TokenKind.NLToken))) { errorCode |= ErrorCodes.IncompleteStatement; } string msg = String.Format(System.Globalization.CultureInfo.InvariantCulture, GetErrorMessage(t, errorCode), t.Image); ReportSyntaxError(start, end, msg, errorCode); }
public override bool Walk(Switch node) { if (_typedChar == '}' && node.GetEndIndex(_tree.LocationResolver) == _position) { Span = GetTargetStatement(node).GetSpan(_tree.LocationResolver); return false; } return base.Walk(node); }