public ParameterSyntax ParseParameter()
{
switch (Tokens.Current)
{
case IRefKeywordToken _:
case IMutableKeywordToken _:
case ISelfKeywordToken _:
{
var span = Tokens.Current.Span;
var refSelf = Tokens.Accept <IRefKeywordToken>();
var mutableSelf = Tokens.Accept <IMutableKeywordToken>();
var selfSpan = Tokens.Expect <ISelfKeywordToken>();
span = TextSpan.Covering(span, selfSpan);
var name = nameContext.Qualify(SpecialName.Self);
return(new SelfParameterSyntax(span, name, refSelf, mutableSelf));
}
case IDotToken _:
{
var dot = Tokens.Expect <IDotToken>();
var identifier = Tokens.RequiredToken <IIdentifierToken>();
var equals = Tokens.AcceptToken <IEqualsToken>();
ExpressionSyntax defaultValue = null;
if (equals != null)
{
defaultValue = ParseExpression();
}
var span = TextSpan.Covering(dot, identifier.Span, defaultValue?.Span);
var name = nameContext.Qualify(SimpleName.Special("field_" + identifier.Value));
return(new FieldParameterSyntax(span, name, defaultValue));
}
default:
{
var span = Tokens.Current.Span;
var isParams = Tokens.Accept <IParamsKeywordToken>();
var mutableBinding = Tokens.Accept <IVarKeywordToken>();
var identifier = Tokens.RequiredToken <IIdentifierOrUnderscoreToken>();
var name = nameContext.Qualify(variableNumbers.VariableName(identifier.Value));
Tokens.Expect <IColonToken>();
// Need to not consume the assignment that separates the type from the default value,
// hence the min operator precedence.
var type = ParseExpression(OperatorPrecedence.AboveAssignment);
ExpressionSyntax defaultValue = null;
if (Tokens.Accept <IEqualsToken>())
{
defaultValue = ParseExpression();
}
span = TextSpan.Covering(span, type.Span, defaultValue?.Span);
return(new NamedParameterSyntax(span, isParams, mutableBinding, name, type, defaultValue));
}
}
}
private SetterDeclarationSyntax ParseSetter(
FixedList <AttributeSyntax> attributes,
FixedList <IModiferToken> modifiers)
{
Tokens.Expect <ISetKeywordToken>();
var identifier = Tokens.RequiredToken <IIdentifierToken>();
var propertyName = nameContext.Qualify(identifier.Value);
var name = nameContext.Qualify(SimpleName.Special("get_" + identifier.Value));
var bodyParser = NestedParser(name);
var parameters = bodyParser.ParseParameters();
var mayEffects = ParseMayEffects();
var noEffects = ParseNoEffects();
var(requires, ensures) = ParseFunctionContracts();
var body = bodyParser.ParseBlock();
return(new SetterDeclarationSyntax(File, attributes, modifiers, propertyName, name,
identifier.Span, parameters, mayEffects, noEffects, requires, ensures, body));
}
public InitializerDeclarationSyntax ParseInitializer(
FixedList <AttributeSyntax> attributes,
FixedList <IModiferToken> modifiers)
{
var initKeywordSpan = Tokens.Expect <IInitKeywordToken>();
var identifier = Tokens.AcceptToken <IIdentifierToken>();
var name = nameContext.Qualify(SimpleName.Special("init" + (identifier != null ? "_" + identifier.Value : "")));
var bodyParser = NestedParser(name);
var genericParameters = AcceptGenericParameters();
var parameters = bodyParser.ParseParameters();
var genericConstraints = ParseGenericConstraints();
var mayEffects = ParseMayEffects();
var noEffects = ParseNoEffects();
var(requires, ensures) = ParseFunctionContracts();
var body = bodyParser.ParseBlock();
return(new InitializerDeclarationSyntax(File, modifiers, name,
TextSpan.Covering(initKeywordSpan, identifier?.Span), genericParameters, parameters,
genericConstraints, mayEffects, noEffects, requires, ensures, body));
}
public OperatorDeclarationSyntax ParseOperator(
FixedList <AttributeSyntax> attributes,
FixedList <IModiferToken> modifiers)
{
var operatorKeyword = Tokens.Expect <IOperatorKeywordToken>();
var genericParameters = AcceptGenericParameters();
// TODO correctly store these in the syntax class
OverloadableOperator oper;
TextSpan endOperatorSpan;
switch (Tokens.Current)
{
case IHashToken _:
Tokens.Expect <IHashToken>();
switch (Tokens.Current)
{
case IOpenParenToken _:
Tokens.Next();
endOperatorSpan = Tokens.Expect <ICloseParenToken>();
oper = OverloadableOperator.TupleInitializer;
break;
case IOpenBracketToken _:
Tokens.Next();
endOperatorSpan = Tokens.Expect <ICloseBracketToken>();
oper = OverloadableOperator.ListInitializer;
break;
case IOpenBraceToken _:
Tokens.Next();
endOperatorSpan = Tokens.Expect <ICloseBraceToken>();
oper = OverloadableOperator.SetInitializer;
break;
default:
throw NonExhaustiveMatchException.For(Tokens.Current);
}
break;
case IStringLiteralToken _:
endOperatorSpan = Tokens.Expect <IStringLiteralToken>();
// TODO need to check it is empty string
oper = OverloadableOperator.StringLiteral;
break;
// TODO case for user defined literals ''
default:
Tokens.UnexpectedToken();
throw new ParseFailedException();
}
var nameSpan = TextSpan.Covering(operatorKeyword, endOperatorSpan);
var name = nameContext.Qualify(SimpleName.Special("op_" + oper));
var bodyParser = NestedParser(name);
var parameters = bodyParser.ParseParameters();
var lifetimeBounds = bodyParser.ParseLifetimeBounds();
ExpressionSyntax returnType = null;
if (Tokens.Accept <IRightArrowToken>())
{
returnType = bodyParser.ParseExpression();
}
var genericConstraints = ParseGenericConstraints();
var mayEffects = ParseMayEffects();
var noEffects = ParseNoEffects();
var(requires, ensures) = ParseFunctionContracts();
var body = bodyParser.ParseBlock();
return(new OperatorDeclarationSyntax(File, modifiers, name, nameSpan, genericParameters,
parameters, lifetimeBounds, returnType, genericConstraints, mayEffects, noEffects, requires,
ensures, body));
}
public static SimpleName Constructor(string name = null)
{
return(name == null ? New : SimpleName.Special("new_" + name));
}
protected SimpleType(string name)
{
Name = SimpleName.Special(name);
}
public static AccessorSymbol NewGetter(Name propertyName, DataType type = null)
{
var getterName = ((QualifiedName)propertyName).Qualifier.Qualify(SimpleName.Special("get_" + propertyName.UnqualifiedName.Text));
return(new AccessorSymbol(getterName, propertyName, type));
}