public override void VisitVariableDeclarationStatement(
VariableDeclarationStatementSyntax variableDeclaration,
Void args)
{
base.VisitVariableDeclarationStatement(variableDeclaration, args);
variableDeclaration.Type.AssertResolved();
}
public ReverseForInStatementSyntax(
VariableDeclarationStatementSyntax variableDeclarationStatement,
IExpressionSyntax collExpression,
IStatementSyntax statements)
: base(variableDeclarationStatement, collExpression, statements)
{
}
public VariableBinding(VariableDeclarationStatementSyntax variableDeclaration)
{
MutableBinding = variableDeclaration.MutableBinding;
BindingName = variableDeclaration.Name;
Name = BindingName.WithoutNumber();
NameSpan = variableDeclaration.NameSpan;
}
public BoundVariableDeclaration(VariableDeclarationStatementSyntax syntax, LocalVariableSymbol variableSymbol, TypeSymbol declaredType, BoundExpression initializerOpt)
: base(BoundNodeKind.VariableDeclaration, syntax)
{
VariableSymbol = variableSymbol;
DeclaredType = declaredType;
InitializerOpt = initializerOpt;
}
public override void VisitVariableDeclarationStatement(VariableDeclarationStatementSyntax node)
{
var variables = node.Declaration.Variables.ToList();
var lastDeclarator = variables.Last();
var firstDeclarator = variables.First();
if (!node.GetFirstToken().Span.IsInRootFile)
{
return;
}
var declarationRootSpan = node.Declaration.GetTextSpanRoot();
var firstDeclaratorTextSpan = TextSpan.FromBounds(declarationRootSpan.SourceText, declarationRootSpan.Start, firstDeclarator.GetTextSpanRoot().End);
if (firstDeclarator == lastDeclarator)
{
firstDeclaratorTextSpan = TextSpan.FromBounds(declarationRootSpan.SourceText, firstDeclaratorTextSpan.Start, node.GetTextSpanRoot().End);
}
ProcessItem(firstDeclarator.Identifier, firstDeclarator.Identifier.Text, firstDeclaratorTextSpan, NavigateToItemKind.Field, node.Parent, Glyph.Variable);
foreach (var declarator in variables.Skip(1))
{
var declaratorTextSpan = declarator.GetTextSpanRoot();
if (declarator == lastDeclarator)
{
declaratorTextSpan = TextSpan.FromBounds(declarationRootSpan.SourceText, declaratorTextSpan.Start, node.GetTextSpanRoot().End);
}
ProcessItem(declarator.Identifier, declarator.Identifier.Text, declaratorTextSpan, NavigateToItemKind.Field, node.Parent, Glyph.Variable);
}
}
public override void VisitVariableDeclarationStatement(
VariableDeclarationStatementSyntax variableDeclaration,
Void args)
{
variableDeclarations.Add(variableDeclaration);
base.VisitVariableDeclarationStatement(variableDeclaration, args);
}
public BoundVariableDeclaration(VariableDeclarationStatementSyntax syntax, LocalVariableSymbol variableSymbol, TypeSymbol declaredType, BoundExpression initializerOpt)
: base(BoundNodeKind.VariableDeclaration, syntax)
{
VariableSymbol = variableSymbol;
DeclaredType = declaredType;
InitializerOpt = initializerOpt;
}
private BoundStatement BindVariableDeclarationStatement(VariableDeclarationStatementSyntax syntax)
{
var isReadOnly = syntax.Keyword.Kind == SyntaxKind.LetKeyword;
var initializer = BindExpression(syntax.Initializer);
var variable = BindVariable(syntax.Identifier, initializer.Type, isReadOnly);
return(new BoundVariableDeclarationStatement(variable, initializer));
}
private static bool IsOwned(VariableDeclarationStatementSyntax declaration)
{
if (declaration.Type is ReferenceType type)
{
return(type.IsOwned);
}
return(false);
}
public BoundVariableDeclarationStatement(
string identifier,
VariableQualifier qualifier,
BoundExpression boundExpression,
VariableDeclarationStatementSyntax syntax)
: base(syntax)
{
Identifier = identifier;
Qualifier = qualifier;
Type = boundExpression.Type;
BoundExpression = boundExpression;
}
public override void VisitVariableDeclarationStatement(
VariableDeclarationStatementSyntax variableDeclaration,
Void args)
{
base.VisitVariableDeclarationStatement(variableDeclaration, args);
var assignToType = variableDeclaration.Type;
var value = variableDeclaration.Initializer;
if (value != null)
{
CheckAssignment(assignToType, value);
}
}
private BoundStatement BindVariableDeclarationStatement(VariableDeclarationStatementSyntax syntax)
{
var initializerExpression = BindExpression(syntax.Initializer);
var isConstant = syntax.KeywordToken.Kind == SyntaxKind.LetKeyword;
var variableSymbol = new VariableSymbol(syntax.IdentifierToken.Text, initializerExpression.Type, isConstant);
if (!_scope.TryDeclareVariable(variableSymbol))
{
_diagnostics.ReportVariableAlreadyDeclared(syntax.IdentifierToken.Span, syntax.IdentifierToken.Text);
}
return(new BoundVariableDeclaration(variableSymbol, initializerExpression));
}
private void BindGlobalVariable(VariableDeclarationStatementSyntax variableDeclarationStatementSyntax)
{
var declaration = variableDeclarationStatementSyntax.Declaration;
foreach (var declarator in declaration.Variables)
{
var variableType = _symbolSet.ResolveType(declaration.Type, null, null);
foreach (var arrayRankSpecifier in declarator.ArrayRankSpecifiers)
variableType = new ArraySymbol(variableType);
var symbol = new GlobalVariableSymbol(declarator, variableType);
_bindingResult.AddSymbol(declarator, symbol);
_symbolSet.AddGlobal(symbol);
}
}
public override void VisitVariableDeclarationStatement(VariableDeclarationStatementSyntax variableDeclaration, BindingScope bindingScope)
{
base.VisitVariableDeclarationStatement(variableDeclaration, bindingScope);
if (bindingScope.Lookup(variableDeclaration.Name, out var binding))
{
if (binding.MutableBinding)
{
diagnostics.Add(SemanticError.CantRebindMutableBinding(function.File, variableDeclaration.NameSpan));
function.Poison();
}
else if (variableDeclaration.MutableBinding)
{
diagnostics.Add(SemanticError.CantRebindAsMutableBinding(function.File, variableDeclaration.NameSpan));
function.Poison();
}
}
}
private void ResolveTypesInVariableDeclaration(
VariableDeclarationStatementSyntax variableDeclaration)
{
InferExpressionType(variableDeclaration.Initializer);
DataType type;
if (variableDeclaration.TypeExpression != null)
{
type = CheckAndEvaluateTypeExpression(variableDeclaration.TypeExpression);
}
else if (variableDeclaration.Initializer != null)
{
type = variableDeclaration.Initializer.Type;
// Use the initializer type unless it is constant
switch (type)
{
case IntegerConstantType integerConstant:
var value = integerConstant.Value;
var byteCount = value.GetByteCount();
type = byteCount <= 4 ? DataType.Int : DataType.Int64;
break;
case StringConstantType stringConstant:
throw new NotImplementedException();
}
}
else
{
diagnostics.Add(TypeError.NotImplemented(file, variableDeclaration.NameSpan,
"Inference of local variable types not implemented"));
type = DataType.Unknown;
}
variableDeclaration.Type = type;
if (variableDeclaration.Initializer != null)
{
InsertImplicitConversionIfNeeded(ref variableDeclaration.Initializer, type);
var initializerType = variableDeclaration.Initializer.Type;
if (!IsAssignableFrom(type, initializerType))
{
diagnostics.Add(TypeError.CannotConvert(file, variableDeclaration.Initializer, initializerType, type));
}
}
}
private IEnumerable <FieldSymbol> BindFields(VariableDeclarationStatementSyntax variableDeclarationStatementSyntax, TypeSymbol parentType)
{
var declaration = variableDeclarationStatementSyntax.Declaration;
foreach (var declarator in declaration.Variables)
{
var variableType = _symbolSet.ResolveType(declaration.Type, null, null);
foreach (var arrayRankSpecifier in declarator.ArrayRankSpecifiers)
{
variableType = new ArraySymbol(variableType);
}
var symbol = new SourceFieldSymbol(declarator, parentType, variableType);
_bindingResult.AddSymbol(declarator, symbol);
yield return(symbol);
}
}
private void BindGlobalVariable(VariableDeclarationStatementSyntax variableDeclarationStatementSyntax)
{
var declaration = variableDeclarationStatementSyntax.Declaration;
foreach (var declarator in declaration.Variables)
{
var variableType = _symbolSet.ResolveType(declaration.Type, null, null);
foreach (var arrayRankSpecifier in declarator.ArrayRankSpecifiers)
{
variableType = new ArraySymbol(variableType);
}
var symbol = new GlobalVariableSymbol(declarator, variableType);
_bindingResult.AddSymbol(declarator, symbol);
_symbolSet.AddGlobal(symbol);
}
}
private BoundMultipleVariableDeclarations BindField(VariableDeclarationStatementSyntax variableDeclarationStatementSyntax, TypeSymbol parentType)
{
var declaration = variableDeclarationStatementSyntax.Declaration;
return(BindVariableDeclaration(declaration, parentType, (d, t) => new SourceFieldSymbol(d, parentType, t)));
}
private BoundMultipleVariableDeclarations BindVariableDeclarationStatement(VariableDeclarationStatementSyntax syntax, Symbol parent)
{
BindAttributes(syntax.Attributes);
return(BindVariableDeclaration(syntax.Declaration, parent));
}
public override IEnumerable <EditorNavigationTarget> VisitVariableDeclarationStatement(VariableDeclarationStatementSyntax node)
{
// The first declarator span includes the initial declaration.
// The last declarator span includes the semicolon.
var variables = node.Declaration.Variables.ToList();
var lastDeclarator = variables.Last();
var firstDeclarator = variables.First();
if (!node.GetFirstToken().Span.IsInRootFile)
{
yield break;
}
var declarationRootSpan = node.Declaration.GetTextSpanRoot();
var firstDeclaratorTextSpan = TextSpan.FromBounds(declarationRootSpan.SourceText, declarationRootSpan.Start, firstDeclarator.GetTextSpanRoot().End);
if (firstDeclarator == lastDeclarator)
{
firstDeclaratorTextSpan = TextSpan.FromBounds(declarationRootSpan.SourceText, firstDeclaratorTextSpan.Start, node.GetTextSpanRoot().End);
}
yield return(CreateTarget(firstDeclarator.Identifier, firstDeclarator.Identifier.Text, firstDeclaratorTextSpan, Glyph.Variable));
foreach (var declarator in variables.Skip(1))
{
var declaratorTextSpan = declarator.GetTextSpanRoot();
if (declarator == lastDeclarator)
{
declaratorTextSpan = TextSpan.FromBounds(declarationRootSpan.SourceText, declaratorTextSpan.Start, node.GetTextSpanRoot().End);
}
yield return(CreateTarget(declarator.Identifier, declarator.Identifier.Text, declaratorTextSpan, Glyph.Variable));
}
}
public virtual void Visit(VariableDeclarationStatementSyntax variableDeclarationStatementSyntax)
{
Visit(variableDeclarationStatementSyntax.InitExpression);
}
private bool ParseVariableDeclarationStatementSyntax(VariableDeclarationStatementSyntax syntax, List <string> registers)
{
VariableDeclarationSyntax varDeclaration = syntax.Declaration;
TypeSyntax type = varDeclaration.Type;
foreach (VariableDeclaratorSyntax var in varDeclaration.Variables)
{
AnnotationFactory.BeginVar();
AnnotationFactory.SetModifiers(varDeclaration.Modifiers);
if (AnnotationFactory.IsGroupOpen())
{
AnnotationFactory.SetType(type);
AnnotationFactory.SetAnnotations(var.Annotations?.Annotations ?? null);
InitializerSyntax initializer = var.Initializer;
if (varDeclaration.Variables[0].ArrayRankSpecifiers.Count > 0)
{
LiteralExpressionSyntax litExpressionSyntax = varDeclaration.Variables[0].ArrayRankSpecifiers[0].Dimension as LiteralExpressionSyntax;
AnnotationFactory.SetDimension((int)litExpressionSyntax.Token.Value);
}
if (initializer != null && initializer is EqualsValueClauseSyntax)
{
EqualsValueClauseSyntax evcSyntax = (EqualsValueClauseSyntax)initializer;
if (evcSyntax.Value is NumericConstructorInvocationExpressionSyntax)
{
NumericConstructorInvocationExpressionSyntax ncieSyntax = (NumericConstructorInvocationExpressionSyntax)evcSyntax.Value;
SeparatedSyntaxList <ExpressionSyntax> arguments = ncieSyntax.ArgumentList.Arguments;
}
else if (evcSyntax.Value is LiteralExpressionSyntax)
{
}
}
SyntaxToken name = var.Identifier;
AnnotationFactory.SetName(name.ValueText);
foreach (var qualifier in var.Qualifiers)
{
if (qualifier is RegisterLocation)
{
string register = ((RegisterLocation)qualifier).Register.ValueText;
if (registers.Contains(register))
{
MessageBox.Show($"Register: {register}\nDefined multiple times, ShaderBox can not decides which one needs to be binded.\n\nWill be resolved in a future release.", "Unsupported operation", MessageBoxButton.OK, MessageBoxImage.Error);
AnnotationFactory.DestroyGroup();
return(false);
}
AnnotationFactory.SetRegister(register);
}
}
if (string.IsNullOrWhiteSpace(AnnotationFactory.GetRegister()))
{
AnnotationFactory.DestroyGroup();
}
else
{
AnnotationFactory.EndVar();
}
}
}
return(true);
}
public virtual void VisitVariableDeclarationStatement(VariableDeclarationStatementSyntax node) => this.DefaultVisit(node);
private IEnumerable<FieldSymbol> BindFields(VariableDeclarationStatementSyntax variableDeclarationStatementSyntax, TypeSymbol parentType)
{
var declaration = variableDeclarationStatementSyntax.Declaration;
foreach (var declarator in declaration.Variables)
{
var variableType = _symbolSet.ResolveType(declaration.Type, null, null);
foreach (var arrayRankSpecifier in declarator.ArrayRankSpecifiers)
variableType = new ArraySymbol(variableType);
var symbol = new SourceFieldSymbol(declarator, parentType, variableType);
_bindingResult.AddSymbol(declarator, symbol);
yield return symbol;
}
}
public VariableBindingScope(BindingScope containingScope, VariableDeclarationStatementSyntax variableDeclaration)
{
ContainingScope = containingScope;
VariableBinding = new VariableBinding(variableDeclaration);
ContainingScope.AddShadowingBinding(VariableBinding);
}
private BoundVariableDeclarationStatement BindVariableDeclarationStatement(VariableDeclarationStatementSyntax syntax)
{
var qualifier = GetQualifier(syntax.Qualifier.Type);
var boundExpression = BindExpression(syntax.InitExpression);
var boundVarDeclStatement = new BoundVariableDeclarationStatement(
syntax.Identifier.Value,
qualifier,
boundExpression,
syntax);
_contextService.AddLocal(syntax.Identifier.Value, boundVarDeclStatement);
return boundVarDeclStatement;
}
public virtual void VisitVariableDeclarationStatement(VariableDeclarationStatementSyntax variableDeclaration, A args)
{
VisitExpression(variableDeclaration.TypeExpression, args);
VisitExpression(variableDeclaration.Initializer, args);
}
public virtual TResult Visit(VariableDeclarationStatementSyntax syntax) => default(TResult);
private BoundMultipleVariableDeclarations BindField(VariableDeclarationStatementSyntax variableDeclarationStatementSyntax, TypeSymbol parentType)
{
var declaration = variableDeclarationStatementSyntax.Declaration;
return BindVariableDeclaration(declaration, parentType, (d, t) => new SourceFieldSymbol(d, parentType, t));
}
public virtual void VisitVariableDeclarationStatement(VariableDeclarationStatementSyntax node)
{
DefaultVisit(node);
}
public override void VisitVariableDeclarationStatement(VariableDeclarationStatementSyntax node)
{
var variables = node.Declaration.Variables.ToList();
var lastDeclarator = variables.Last();
var firstDeclarator = variables.First();
if (!node.GetFirstToken().Span.IsInRootFile)
return;
var declarationRootSpan = node.Declaration.GetTextSpanRoot();
var firstDeclaratorTextSpan = TextSpan.FromBounds(declarationRootSpan.SourceText, declarationRootSpan.Start, firstDeclarator.GetTextSpanRoot().End);
if (firstDeclarator == lastDeclarator)
firstDeclaratorTextSpan = TextSpan.FromBounds(declarationRootSpan.SourceText, firstDeclaratorTextSpan.Start, node.GetTextSpanRoot().End);
ProcessItem(firstDeclarator.Identifier, firstDeclarator.Identifier.Text, firstDeclaratorTextSpan, NavigateToItemKind.Field, node.Parent, Glyph.Variable);
foreach (var declarator in variables.Skip(1))
{
var declaratorTextSpan = declarator.GetTextSpanRoot();
if (declarator == lastDeclarator)
declaratorTextSpan = TextSpan.FromBounds(declarationRootSpan.SourceText, declaratorTextSpan.Start, node.GetTextSpanRoot().End);
ProcessItem(declarator.Identifier, declarator.Identifier.Text, declaratorTextSpan, NavigateToItemKind.Field, node.Parent, Glyph.Variable);
}
}
private BoundMultipleVariableDeclarations BindVariableDeclarationStatement(VariableDeclarationStatementSyntax syntax, Symbol parent)
{
BindAttributes(syntax.Attributes);
return BindVariableDeclaration(syntax.Declaration, parent);
}
