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);
}
internal void SetLoc(int start, int end)
{
_span = new IndexSpan(start, end >= start ? end - start : start);
}
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);
}
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 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);
}
internal void SetLoc(IndexSpan span)
{
_span = span;
}
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);
}
