public InstanceFunctionCallSyntax(SyntaxBase baseExpression, Token dot, IdentifierSyntax name, Token openParen, IEnumerable <SyntaxBase> children, Token closeParen)
: base(name, openParen, children, closeParen)
{
AssertTokenType(dot, nameof(dot), TokenType.Dot);
this.BaseExpression = baseExpression;
this.Dot = dot;
}
public ResourceAccessSyntax(SyntaxBase baseExpression, Token doubleColon, IdentifierSyntax resourceName)
{
AssertTokenType(doubleColon, nameof(doubleColon), TokenType.DoubleColon);
this.BaseExpression = baseExpression;
this.DoubleColon = doubleColon;
this.ResourceName = resourceName;
}
public PropertyAccessSyntax(SyntaxBase baseExpression, Token dot, IdentifierSyntax propertyName)
{
AssertTokenType(dot, nameof(dot), TokenType.Dot);
this.BaseExpression = baseExpression;
this.Dot = dot;
this.PropertyName = propertyName;
}
public ParameterDeclarationSyntax(Token parameterKeyword, IdentifierSyntax name, TypeSyntax type, SyntaxBase?modifier)
{
AssertKeyword(parameterKeyword, nameof(parameterKeyword), LanguageConstants.ParameterKeyword);
AssertSyntaxType(modifier, nameof(modifier), typeof(ParameterDefaultValueSyntax), typeof(ObjectSyntax));
this.ParameterKeyword = parameterKeyword;
this.Name = name;
this.Type = type;
this.Modifier = modifier;
}
public FunctionCallSyntax(IdentifierSyntax name, Token openParen, IEnumerable <FunctionArgumentSyntax> arguments, Token closeParen)
{
AssertTokenType(openParen, nameof(openParen), TokenType.LeftParen);
AssertTokenType(closeParen, nameof(closeParen), TokenType.RightParen);
this.Name = name;
this.OpenParen = openParen;
this.Arguments = arguments.ToImmutableArray();
this.CloseParen = closeParen;
}
public VariableDeclarationSyntax(Token variableKeyword, IdentifierSyntax name, Token assignment, SyntaxBase value)
{
AssertKeyword(variableKeyword, nameof(variableKeyword), LanguageConstants.VariableKeyword);
AssertTokenType(assignment, nameof(assignment), TokenType.Assignment);
this.VariableKeyword = variableKeyword;
this.Name = name;
this.Assignment = assignment;
this.Value = value;
}
protected FunctionCallSyntaxBase(IdentifierSyntax name, Token openParen, IEnumerable <SyntaxBase> children, Token closeParen)
{
AssertTokenType(openParen, nameof(openParen), TokenType.LeftParen);
AssertTokenType(closeParen, nameof(closeParen), TokenType.RightParen);
this.Name = name;
this.OpenParen = openParen;
this.Children = children.ToImmutableArray();
this.CloseParen = closeParen;
}
public OutputDeclarationSyntax(Token outputKeyword, IdentifierSyntax name, TypeSyntax type, Token assignment, SyntaxBase value)
{
AssertKeyword(outputKeyword, nameof(outputKeyword), LanguageConstants.OutputKeyword);
AssertTokenType(assignment, nameof(assignment), TokenType.Assignment);
this.OutputKeyword = outputKeyword;
this.Name = name;
this.Type = type;
this.Assignment = assignment;
this.Value = value;
}
protected virtual SyntaxBase ReplaceIdentifierSyntax(IdentifierSyntax syntax)
{
var hasChanges = TryRewrite(syntax.Child, out var child);
if (!hasChanges)
{
return(syntax);
}
return(new IdentifierSyntax(child));
}
public ParameterDeclarationSyntax(Token keyword, IdentifierSyntax name, SyntaxBase type, SyntaxBase?modifier)
{
AssertKeyword(keyword, nameof(keyword), LanguageConstants.ParameterKeyword);
AssertSyntaxType(name, nameof(name), typeof(IdentifierSyntax));
AssertSyntaxType(type, nameof(type), typeof(TypeSyntax), typeof(SkippedTriviaSyntax));
AssertSyntaxType(modifier, nameof(modifier), typeof(ParameterDefaultValueSyntax), typeof(ObjectSyntax), typeof(SkippedTriviaSyntax));
this.Keyword = keyword;
this.Name = name;
this.Type = type;
this.Modifier = modifier;
}
public VariableDeclarationSyntax(Token keyword, IdentifierSyntax name, SyntaxBase assignment, SyntaxBase value)
{
AssertKeyword(keyword, nameof(keyword), LanguageConstants.VariableKeyword);
AssertSyntaxType(name, nameof(name), typeof(IdentifierSyntax));
AssertSyntaxType(assignment, nameof(assignment), typeof(Token), typeof(SkippedTriviaSyntax));
AssertTokenType(assignment as Token, nameof(assignment), TokenType.Assignment);
this.Keyword = keyword;
this.Name = name;
this.Assignment = assignment;
this.Value = value;
}
public ResourceDeclarationSyntax(Token resourceKeyword, IdentifierSyntax name, SyntaxBase type, Token assignment, SyntaxBase body)
{
AssertKeyword(resourceKeyword, nameof(resourceKeyword), LanguageConstants.ResourceKeyword);
AssertTokenType(resourceKeyword, nameof(resourceKeyword), TokenType.Identifier);
AssertTokenType(assignment, nameof(assignment), TokenType.Assignment);
this.ResourceKeyword = resourceKeyword;
this.Name = name;
this.Type = type;
this.Assignment = assignment;
this.Body = body;
}
public InstanceFunctionCallSyntax(SyntaxBase baseExpression, Token dot, IdentifierSyntax name, Token openParen, IEnumerable <FunctionArgumentSyntax> arguments, Token closeParen)
{
AssertTokenType(openParen, nameof(openParen), TokenType.LeftParen);
AssertTokenType(closeParen, nameof(closeParen), TokenType.RightParen);
AssertTokenType(dot, nameof(dot), TokenType.Dot);
this.BaseExpression = baseExpression;
this.Dot = dot;
this.Name = name;
this.OpenParen = openParen;
this.Arguments = arguments.ToImmutableArray();
this.CloseParen = closeParen;
}
public ResourceDeclarationSyntax(Token keyword, IdentifierSyntax name, SyntaxBase type, SyntaxBase assignment, SyntaxBase body)
{
AssertKeyword(keyword, nameof(keyword), LanguageConstants.ResourceKeyword);
AssertSyntaxType(name, nameof(name), typeof(IdentifierSyntax));
AssertSyntaxType(type, nameof(type), typeof(StringSyntax), typeof(SkippedTriviaSyntax));
AssertTokenType(keyword, nameof(keyword), TokenType.Identifier);
AssertSyntaxType(assignment, nameof(assignment), typeof(Token), typeof(SkippedTriviaSyntax));
AssertTokenType(assignment as Token, nameof(assignment), TokenType.Assignment);
this.Keyword = keyword;
this.Name = name;
this.Type = type;
this.Assignment = assignment;
this.Body = body;
}
public ModuleDeclarationSyntax(Token keyword, IdentifierSyntax name, SyntaxBase path, SyntaxBase assignment, SyntaxBase body)
{
AssertKeyword(keyword, nameof(keyword), LanguageConstants.ModuleKeyword);
AssertSyntaxType(name, nameof(name), typeof(IdentifierSyntax));
AssertSyntaxType(path, nameof(path), typeof(StringSyntax), typeof(SkippedTriviaSyntax));
AssertTokenType(keyword, nameof(keyword), TokenType.Identifier);
AssertSyntaxType(assignment, nameof(assignment), typeof(Token), typeof(SkippedTriviaSyntax));
AssertTokenType(assignment as Token, nameof(assignment), TokenType.Assignment);
AssertSyntaxType(body, nameof(body), typeof(SkippedTriviaSyntax), typeof(ObjectSyntax));
this.Keyword = keyword;
this.Name = name;
this.Path = path;
this.Assignment = assignment;
this.Body = body;
}
public FunctionCallSyntax(IdentifierSyntax name, Token openParen, IEnumerable <FunctionArgumentSyntax> arguments, Token closeParen)
: base(name, openParen, arguments, closeParen)
{
}
public ModuleDeclarationSyntax(IEnumerable <SyntaxBase> leadingNodes, Token keyword, IdentifierSyntax name, SyntaxBase path, SyntaxBase assignment, SyntaxBase value)
: base(leadingNodes)
{
AssertKeyword(keyword, nameof(keyword), LanguageConstants.ModuleKeyword);
AssertSyntaxType(name, nameof(name), typeof(IdentifierSyntax));
AssertSyntaxType(path, nameof(path), typeof(StringSyntax), typeof(SkippedTriviaSyntax));
AssertTokenType(keyword, nameof(keyword), TokenType.Identifier);
AssertSyntaxType(assignment, nameof(assignment), typeof(Token), typeof(SkippedTriviaSyntax));
AssertTokenType(assignment as Token, nameof(assignment), TokenType.Assignment);
AssertSyntaxType(value, nameof(value), typeof(SkippedTriviaSyntax), typeof(ObjectSyntax), typeof(IfConditionSyntax), typeof(ForSyntax));
this.Keyword = keyword;
this.Name = name;
this.Path = path;
this.Assignment = assignment;
this.Value = value;
}
public virtual void VisitIdentifierSyntax(IdentifierSyntax syntax)
{
this.Visit(syntax.Child);
}
public FunctionCallSyntax(IdentifierSyntax name, Token openParen, IEnumerable <SyntaxBase> children, Token closeParen)
: base(name, openParen, children, closeParen)
{
}
public VariableAccessSyntax(IdentifierSyntax name)
{
this.Name = name;
}
public static bool NameEquals(this IdentifierSyntax identifier, string compareTo) => LanguageConstants.IdentifierComparer.Equals(identifier.IdentifierName, compareTo);
public ImportDeclarationSyntax(IEnumerable <SyntaxBase> leadingNodes, Token keyword, IdentifierSyntax providerName, SyntaxBase asKeyword, IdentifierSyntax aliasName, SyntaxBase?config)
: base(leadingNodes)
{
AssertKeyword(keyword, nameof(keyword), LanguageConstants.ImportKeyword);
AssertSyntaxType(providerName, nameof(providerName), typeof(IdentifierSyntax));
AssertSyntaxType(asKeyword, nameof(asKeyword), typeof(Token), typeof(SkippedTriviaSyntax));
AssertSyntaxType(aliasName, nameof(aliasName), typeof(IdentifierSyntax));
AssertSyntaxType(config, nameof(config), typeof(ObjectSyntax), typeof(SkippedTriviaSyntax));
this.Keyword = keyword;
this.ProviderName = providerName;
this.AsKeyword = asKeyword;
this.AliasName = aliasName;
this.Config = config;
}
public OutputDeclarationSyntax(IEnumerable <SyntaxBase> leadingNodes, Token keyword, IdentifierSyntax name, SyntaxBase type, SyntaxBase assignment, SyntaxBase value)
: base(leadingNodes)
{
AssertKeyword(keyword, nameof(keyword), LanguageConstants.OutputKeyword);
AssertSyntaxType(name, nameof(name), typeof(IdentifierSyntax), typeof(IdentifierSyntax));
AssertSyntaxType(type, nameof(type), typeof(SimpleTypeSyntax), typeof(ResourceTypeSyntax), typeof(SkippedTriviaSyntax));
AssertSyntaxType(assignment, nameof(assignment), typeof(Token), typeof(SkippedTriviaSyntax));
AssertTokenType(assignment as Token, nameof(assignment), TokenType.Assignment);
this.Keyword = keyword;
this.Name = name;
this.Type = type;
this.Assignment = assignment;
this.Value = value;
}
public LocalVariableSyntax(IdentifierSyntax name)
{
this.Name = name;
}
public ResourceDeclarationSyntax(IEnumerable <SyntaxBase> leadingNodes, Token keyword, IdentifierSyntax name, SyntaxBase type, Token?existingKeyword, SyntaxBase assignment, SyntaxBase value)
: base(leadingNodes)
{
AssertKeyword(keyword, nameof(keyword), LanguageConstants.ResourceKeyword);
AssertSyntaxType(name, nameof(name), typeof(IdentifierSyntax));
AssertSyntaxType(type, nameof(type), typeof(StringSyntax), typeof(SkippedTriviaSyntax));
AssertKeyword(existingKeyword, nameof(existingKeyword), LanguageConstants.ExistingKeyword);
AssertTokenType(keyword, nameof(keyword), TokenType.Identifier);
AssertSyntaxType(assignment, nameof(assignment), typeof(Token), typeof(SkippedTriviaSyntax));
AssertTokenType(assignment as Token, nameof(assignment), TokenType.Assignment);
AssertSyntaxType(value, nameof(value), typeof(SkippedTriviaSyntax), typeof(ObjectSyntax), typeof(IfConditionSyntax), typeof(ForSyntax));
this.Keyword = keyword;
this.Name = name;
this.Type = type;
this.ExistingKeyword = existingKeyword;
this.Assignment = assignment;
this.Value = value;
}
public virtual void VisitIdentifierSyntax(IdentifierSyntax syntax)
{
this.VisitToken(syntax.Identifier);
}
public ResourceDeclarationSyntax(IEnumerable <SyntaxBase> leadingNodes, Token keyword, IdentifierSyntax name, SyntaxBase type, SyntaxBase assignment, SyntaxBase?ifCondition, SyntaxBase body)
: base(leadingNodes)
{
AssertKeyword(keyword, nameof(keyword), LanguageConstants.ResourceKeyword);
AssertSyntaxType(name, nameof(name), typeof(IdentifierSyntax));
AssertSyntaxType(type, nameof(type), typeof(StringSyntax), typeof(SkippedTriviaSyntax));
AssertTokenType(keyword, nameof(keyword), TokenType.Identifier);
AssertSyntaxType(assignment, nameof(assignment), typeof(Token), typeof(SkippedTriviaSyntax));
AssertTokenType(assignment as Token, nameof(assignment), TokenType.Assignment);
AssertSyntaxType(ifCondition, nameof(ifCondition), typeof(SkippedTriviaSyntax), typeof(IfConditionSyntax));
AssertSyntaxType(body, nameof(body), typeof(SkippedTriviaSyntax), typeof(ObjectSyntax));
this.Keyword = keyword;
this.Name = name;
this.Type = type;
this.Assignment = assignment;
this.IfCondition = ifCondition;
this.Body = body;
}
void ISyntaxVisitor.VisitIdentifierSyntax(IdentifierSyntax syntax) => ReplaceCurrent(syntax, ReplaceIdentifierSyntax);
public ParameterDeclarationSyntax(IEnumerable <SyntaxBase> leadingNodes, Token keyword, IdentifierSyntax name, SyntaxBase type, SyntaxBase?modifier)
: base(leadingNodes)
{
AssertKeyword(keyword, nameof(keyword), LanguageConstants.ParameterKeyword);
AssertSyntaxType(name, nameof(name), typeof(IdentifierSyntax));
AssertSyntaxType(type, nameof(type), typeof(SimpleTypeSyntax), typeof(ResourceTypeSyntax), typeof(SkippedTriviaSyntax));
AssertSyntaxType(modifier, nameof(modifier), typeof(ParameterDefaultValueSyntax), typeof(SkippedTriviaSyntax));
this.Keyword = keyword;
this.Name = name;
this.Type = type;
this.Modifier = modifier;
}