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