public PtLambdaCaptureName(PonyTokenSpan span, PtIdentifier name, PtType?type, PtExpression?value)
: base(span)
{
Name = name;
Type = type;
Value = value;
}
public PtMethod(PonyTokenSpan span,
PtMethodKind kind,
PtAnnotations?annotations,
bool bare,
PtCap?receiverCap,
PtIdentifier name,
PtTypeParameters?typeParameters,
PtParameters parameters,
PtType?returnType,
bool partial,
PtString?doc,
PtExpression?body)
: base(span)
{
Kind = kind;
Annotations = annotations;
Bare = bare;
ReceiverCap = receiverCap;
Name = name;
TypeParameters = typeParameters;
Parameters = parameters;
ReturnType = returnType;
Partial = partial;
Doc = doc;
Body = body;
}
public PtUnit(PonyTokenSpan span, PtString?doc, IReadOnlyList <PtUse> uses, IReadOnlyList <PtClass> classes)
: base(span)
{
Doc = doc;
Uses = uses;
Classes = classes;
}
public PtTypeParameter(PonyTokenSpan span, PtIdentifier name, PtType?type, PtType?defaultType)
: base(span)
{
Name = name;
Type = type;
DefaultType = defaultType;
}
public PtLambda(PonyTokenSpan span,
bool bare,
PtAnnotations?annotations,
PtCap?receiverCap,
PtIdentifier?name,
PtTypeParameters?typeParameters,
PtLambdaParameters parameters,
PtLambdaCaptures?captures,
PtType?returnType,
bool partial,
PtExpression?body,
PtCap?referenceCap)
: base(span)
{
Bare = bare;
Annotations = annotations;
ReceiverCap = receiverCap;
Name = name;
TypeParameters = typeParameters;
Parameters = parameters;
Captures = captures;
ReturnType = returnType;
Partial = partial;
Body = body;
ReferenceCap = referenceCap;
}
public PtLocal(PonyTokenSpan span, PtLocalKind kind, PtIdentifier name, PtType?type)
: base(span)
{
Kind = kind;
Name = name;
Type = type;
}
public PtRegularParameter(PonyTokenSpan span, PtIdentifier name, PtType type, PtExpression?value)
: base(span)
{
Name = name;
Type = type;
Value = value;
}
public PtWith(PonyTokenSpan span, PtAnnotations?annotations, PtWithElements elements, PtExpression body, PtElse?elsePart)
: base(span)
{
Annotations = annotations;
Elements = elements;
Body = body;
ElsePart = elsePart;
}
public PtField(PonyTokenSpan span, PtFieldKind kind, PtIdentifier name, PtType type, PtExpression?value, PtString?doc)
: base(span)
{
Kind = kind;
Name = name;
Type = type;
Value = value;
}
public PtBinary(PonyTokenSpan span, PtBinaryKind kind, IReadOnlyList <PtExpression> operands)
: base(span)
{
Debug.Assert(operands.Count >= 2);
Kind = kind;
Operands = operands;
}
public PtFfiCall(PonyTokenSpan span, PtExpression name, PtTypeArguments?returnType, PtArguments arguments, bool partial)
: base(span)
{
Name = name;
ReturnType = returnType;
Arguments = arguments;
Partial = partial;
}
public PtMatch(PonyTokenSpan span, PtAnnotations?annotations, PtExpression toMatch, PtCases cases, PtExpression?elsePart)
: base(span)
{
Annotations = annotations;
ToMatch = toMatch;
Cases = cases;
ElsePart = elsePart;
}
public PtNominalType(PonyTokenSpan span, PtIdentifier name, PtTypeArguments?typeArguments, PtCap?cap, PtEphemAlias?ea)
: base(span)
{
Name = name;
TypeArguments = typeArguments;
Cap = cap;
Ea = ea;
}
public PtTry(PonyTokenSpan span, PtAnnotations?annotations, PtExpression body, PtExpression?elsePart, PtExpression?thenPart)
: base(span)
{
Annotations = annotations;
Body = body;
ElsePart = elsePart;
ThenPart = thenPart;
}
public PtObject(PonyTokenSpan span, PtAnnotations?annotations, PtCap?cap, PtType?provides, PtMembers members)
: base(span)
{
Annotations = annotations;
Cap = cap;
Provides = provides;
Members = members;
}
public PtCase(PonyTokenSpan span, PtAnnotations?annotations, PtExpression?pattern, PtExpression?guard, PtExpression?body)
: base(span)
{
Annotations = annotations;
Pattern = pattern;
Guard = guard;
Body = body;
}
public PtRepeat(PonyTokenSpan span, PtAnnotations?annotations, PtExpression body, PtExpression condition, PtElse?elsePart)
: base(span)
{
Annotations = annotations;
Body = body;
Condition = condition;
ElsePart = elsePart;
}
private static double CreateValue(PonyTokenSpan span)
{
Debug.Assert(span.Length == 1);
var str = span[0].GetPayload().Replace("_", string.Empty);
var value = double.Parse(str, NumberStyles.Float, CultureInfo.InvariantCulture);
return(value);
}
public PtIff(PonyTokenSpan span, PtIffKind kind, PtAnnotations?annotations, PtExpression condition, PtExpression thenPart, PtExpression?elsePart)
: base(span)
{
Kind = kind;
Annotations = annotations;
Condition = condition;
ThenPart = thenPart;
ElsePart = elsePart;
}
public PtFor(PonyTokenSpan span, PtAnnotations?annotations, PtIds names, PtExpression iterator, PtExpression body, PtExpression?elsePart)
: base(span)
{
Annotations = annotations;
Names = names;
Iterator = iterator;
Body = body;
ElsePart = elsePart;
}
private static string CreateValue(PonyTokenSpan span)
{
Debug.Assert(span.Length == 1);
var value = span[0].GetPayload();
//Debug.Assert(!value.Contains("\\"));
if (value.StartsWith("\"\"\""))
{
value = value[3..^ 3];
public PtUseFfi(PonyTokenSpan span, PtIdentifier?alias, PtFfiName ffiName, PtTypeArguments typeArguments, PtParameters parameters, bool partial, PtGuard?guard)
: base(span, alias, guard)
{
Debug.Assert(alias == null);
Debug.Assert(!partial);
FfiName = ffiName;
TypeArguments = typeArguments;
Parameters = parameters;
Partial = partial;
}
private static BigInteger CreateValue(PonyTokenSpan span)
{
Debug.Assert(span.Length == 1);
var str = span[0].GetPayload().Replace("_", string.Empty);
BigInteger value;
if (str.StartsWith("0x"))
{
value = BigInteger.Parse(str.Substring(2), NumberStyles.HexNumber);
}
else
{
value = BigInteger.Parse(str);
}
return(value);
}
public PtLambdaType(PonyTokenSpan span,
bool bare,
PtCap?receiverCap,
PtIdentifier?name,
PtTypeParameters?typeParameters,
PtLambdaTypeParameters parameters,
PtType?returnType,
bool partial,
PtCap?referenceCap,
PtEphemAlias?ea)
: base(span)
{
Bare = bare;
ReceiverCap = receiverCap;
Name = name;
TypeParameters = typeParameters;
Parameters = parameters;
ReturnType = returnType;
Partial = partial;
ReferenceCap = referenceCap;
Ea = ea;
}
public PtClass(PonyTokenSpan span,
PtClassKind kind,
PtAnnotations?annotations,
bool bare,
PtCap?cap,
PtIdentifier name,
PtTypeParameters?typeParameters,
PtType?provides,
PtString?doc,
PtMembers members)
: base(span)
{
Kind = kind;
Annotations = annotations;
Bare = bare;
Cap = cap;
Name = name;
TypeParameters = typeParameters;
Provides = provides;
Doc = doc;
Members = members;
}
public PtLiteral(PonyTokenSpan span, T value)
: base(span)
{
Value = value;
}
public PtFields(PonyTokenSpan span, IReadOnlyList <PtField> items)
: base(span)
{
Items = items;
}
public PtArgument(PonyTokenSpan span)
: base(span)
{
}
public PtInt(PonyTokenSpan span)
: base(span, CreateValue(span))
{
}
public InfixTypePart(PonyTokenSpan span, PtInfixTypeKind kind, PtType right)
: base(span)
{
Kind = kind;
Right = right;
}
