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