public static glsl.EqualsValueClauseSyntax Translate(this cs.EqualsValueClauseSyntax node) { return(new glsl.EqualsValueClauseSyntax().Update( node.EqualsToken, node.Value.Translate() )); }
public static LocalDeclarationStatementSyntax Declaration(string type, string variableName, EqualsValueClauseSyntax equalsValue) { return SyntaxFactory.LocalDeclarationStatement( SyntaxFactory.VariableDeclaration(Identifier.Name(type)) .WithVariables(Declarator(variableName, equalsValue).AsList())) .WithSemicolonToken(Token.SemiColon); }
public static FieldDeclarationSyntax PrivateDeclation(string type, string variableName, EqualsValueClauseSyntax equalsValue) { return SyntaxFactory.FieldDeclaration(Declaration(SyntaxFactory.ParseTypeName(type), SyntaxFactory.VariableDeclarator( Identifier.Token(variableName), null, equalsValue))) .WithModifiers(Token.Private.AsList()); }
public static SourceLocalSymbol MakeLocal( MethodSymbol containingMethod, Binder binder, TypeSyntax typeSyntax, SyntaxToken identifierToken, EqualsValueClauseSyntax initializer, LocalDeclarationKind declarationKind) { Debug.Assert(declarationKind != LocalDeclarationKind.ForEach); return new SourceLocalSymbol(containingMethod, binder, typeSyntax, identifierToken, initializer, null, declarationKind); }
public static SourceLocalSymbol MakeLocalWithInitializer( Symbol containingSymbol, Binder binder, TypeSyntax typeSyntax, SyntaxToken identifierToken, EqualsValueClauseSyntax initializer, LocalDeclarationKind declarationKind) { Debug.Assert(declarationKind != LocalDeclarationKind.ForEachIterationVariable); return new LocalWithInitializer(containingSymbol, binder, typeSyntax, identifierToken, initializer, declarationKind); }
private CSSyntax.VariableDeclarationSyntax CreateVariableDeclaration(VariableDeclaratorSyntax vbDeclarator, bool preferExplicitType, bool requireExplicitTypeForAll, ITypeSymbol vbInitializerType, ITypeSymbol declaredSymbolType, CSSyntax.EqualsValueClauseSyntax equalsValueClauseSyntax, IMethodSymbol initSymbol, CSSyntax.VariableDeclaratorSyntax v) { var requireExplicitType = requireExplicitTypeForAll || vbInitializerType != null && !Equals(declaredSymbolType, vbInitializerType); bool useVar = equalsValueClauseSyntax != null && !preferExplicitType && !requireExplicitType; var typeSyntax = initSymbol == null || !initSymbol.IsAnonymousFunction() ? GetTypeSyntax(declaredSymbolType, useVar) : GetFuncTypeSyntax(initSymbol); return(SyntaxFactory.VariableDeclaration(typeSyntax, SyntaxFactory.SingletonSeparatedList(v))); }
public static PropertyDeclarationSyntax PropertyDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, TypeSyntax type, ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, SyntaxToken identifier, AccessorListSyntax accessorList, ArrowExpressionClauseSyntax expressionBody, EqualsValueClauseSyntax initializer, SyntaxToken semicolonToken) { return PropertyDeclaration( attributeLists, modifiers, refKeyword: default(SyntaxToken), type: type, explicitInterfaceSpecifier: explicitInterfaceSpecifier, identifier: identifier, accessorList: accessorList, expressionBody: expressionBody, initializer: initializer, semicolonToken: semicolonToken); }
private static BoundExpression BindFieldOrEnumInitializer( Binder binder, FieldSymbol fieldSymbol, EqualsValueClauseSyntax initializer, DiagnosticBag diagnostics) { var enumConstant = fieldSymbol as SourceEnumConstantSymbol; var collisionDetector = new LocalScopeBinder(binder); if ((object)enumConstant != null) { return collisionDetector.BindEnumConstantInitializer(enumConstant, initializer.Value, diagnostics); } else { return collisionDetector.BindVariableOrAutoPropInitializer(initializer, fieldSymbol.Type, diagnostics); } }
private SourceLocalSymbol( MethodSymbol containingMethod, Binder binder, TypeSyntax typeSyntax, SyntaxToken identifierToken, EqualsValueClauseSyntax initializer, ExpressionSyntax collection, LocalDeclarationKind declarationKind) { Debug.Assert(identifierToken.CSharpKind() != SyntaxKind.None); Debug.Assert(declarationKind != LocalDeclarationKind.CompilerGenerated); this.binder = binder; this.containingMethod = containingMethod; this.identifierToken = identifierToken; this.typeSyntax = typeSyntax; this.initializer = initializer; this.collection = collection; this.declarationKind = declarationKind; // create this eagerly as it will always be needed for the EnsureSingleDefinition this.locations = ImmutableArray.Create<Location>(identifierToken.GetLocation()); }
public static ConstantValue EvaluateFieldConstant( SourceFieldSymbol symbol, EqualsValueClauseSyntax equalsValueNode, HashSet<SourceFieldSymbolWithSyntaxReference> dependencies, bool earlyDecodingWellKnownAttributes, DiagnosticBag diagnostics) { var compilation = symbol.DeclaringCompilation; var binderFactory = compilation.GetBinderFactory((SyntaxTree)symbol.Locations[0].SourceTree); var binder = binderFactory.GetBinder(equalsValueNode); if (earlyDecodingWellKnownAttributes) { binder = new EarlyWellKnownAttributeBinder(binder); } var inProgressBinder = new ConstantFieldsInProgressBinder(new ConstantFieldsInProgress(symbol, dependencies), binder); var boundValue = BindFieldOrEnumInitializer(inProgressBinder, symbol, equalsValueNode, diagnostics); var initValueNodeLocation = equalsValueNode.Value.Location; var value = GetAndValidateConstantValue(boundValue, symbol, symbol.Type, initValueNodeLocation, diagnostics); Debug.Assert(value != null); return value; }
public static SourceLocalSymbol MakeLocal( Symbol containingSymbol, Binder binder, RefKind refKind, TypeSyntax typeSyntax, SyntaxToken identifierToken, LocalDeclarationKind declarationKind, EqualsValueClauseSyntax initializer = null) { Debug.Assert(declarationKind != LocalDeclarationKind.ForEachIterationVariable); if (initializer == null) { DeclarationExpressionSyntax declarationExpression; if (identifierToken.IsIdentifierOfOutVariableDeclaration(out declarationExpression)) { if (declarationExpression.Type().IsVar) { return new PossiblyImplicitlyTypedOutVarLocalSymbol(containingSymbol, binder, refKind, typeSyntax, identifierToken, declarationKind); } } return new SourceLocalSymbol(containingSymbol, binder, refKind, typeSyntax, identifierToken, declarationKind); } return new LocalWithInitializer(containingSymbol, binder, refKind, typeSyntax, identifierToken, initializer, declarationKind); }
private static BoundFieldInitializer BindFieldInitializer(Binder binder, FieldSymbol fieldSymbol, EqualsValueClauseSyntax equalsValueClauseNode, DiagnosticBag diagnostics) { Debug.Assert(!fieldSymbol.IsMetadataConstant); var fieldsBeingBound = binder.FieldsBeingBound; var sourceField = fieldSymbol as SourceMemberFieldSymbol; bool isImplicitlyTypedField = (object)sourceField != null && sourceField.FieldTypeInferred(fieldsBeingBound); // If the type is implicitly typed, the initializer diagnostics have already been reported, so ignore them here: // CONSIDER (tomat): reusing the bound field initializers for implicitly typed fields. DiagnosticBag initializerDiagnostics; if (isImplicitlyTypedField) { initializerDiagnostics = DiagnosticBag.GetInstance(); } else { initializerDiagnostics = diagnostics; } var collisionDetector = new LocalScopeBinder(binder); var boundInitValue = collisionDetector.BindVariableOrAutoPropInitializer(equalsValueClauseNode, fieldSymbol.GetFieldType(fieldsBeingBound), initializerDiagnostics); if (isImplicitlyTypedField) { initializerDiagnostics.Free(); } return new BoundFieldInitializer( equalsValueClauseNode.Value, //we want the attached sequence point to indicate the value node fieldSymbol, boundInitValue); }
// The location where the error is reported might not be the initializer. internal BoundExpression BindInferredVariableInitializer(DiagnosticBag diagnostics, EqualsValueClauseSyntax initializer, CSharpSyntaxNode errorSyntax) { if (initializer == null) { if (!errorSyntax.HasErrors) { Error(diagnostics, ErrorCode.ERR_ImplicitlyTypedVariableWithNoInitializer, errorSyntax); } return null; } if (initializer.Value.Kind() == SyntaxKind.ArrayInitializerExpression) { return BindUnexpectedArrayInitializer((InitializerExpressionSyntax)initializer.Value, diagnostics, ErrorCode.ERR_ImplicitlyTypedVariableAssignedArrayInitializer, errorSyntax); } BoundExpression expression = BindValue(initializer.Value, diagnostics, BindValueKind.RValue); // Certain expressions (null literals, method groups and anonymous functions) have no type of // their own and therefore cannot be the initializer of an implicitly typed local. if (!expression.HasAnyErrors && !expression.HasExpressionType()) { MessageID id = MessageID.IDS_NULL; if (expression.Kind == BoundKind.UnboundLambda) { id = ((UnboundLambda)expression).MessageID; } else if (expression.Kind == BoundKind.MethodGroup) { id = MessageID.IDS_MethodGroup; } else { Debug.Assert(expression.IsLiteralNull(), "How did we successfully bind an expression without a type?"); } // Cannot assign {0} to an implicitly-typed local variable Error(diagnostics, ErrorCode.ERR_ImplicitlyTypedVariableAssignedBadValue, errorSyntax, id.Localize()); } return expression; }
public override void VisitEqualsValueClause(EqualsValueClauseSyntax node) { base.VisitEqualsValueClause(node); if (node.Parent != null && node.Parent.IsKind(SyntaxKind.PropertyDeclaration)) { var symbol = context.SemanticModel.GetDeclaredSymbol((PropertyDeclarationSyntax)node.Parent); if (symbol != null) { CheckAssignment(symbol, node.Value); } } }
private SourceLocalSymbol LocateDeclaredVariableSymbol(SyntaxToken identifier, TypeSyntax typeSyntax, EqualsValueClauseSyntax equalsValue) { SourceLocalSymbol localSymbol = this.LookupLocal(identifier); // In error scenarios with misplaced code, it is possible we can't bind the local declaration. // This occurs through the semantic model. In that case concoct a plausible result. if ((object)localSymbol == null) { localSymbol = SourceLocalSymbol.MakeLocal( ContainingMemberOrLambda, this, false, // do not allow ref typeSyntax, identifier, LocalDeclarationKind.RegularVariable, equalsValue); } return localSymbol; }
// The location where the error is reported might not be the initializer. protected BoundExpression BindInferredVariableInitializer(DiagnosticBag diagnostics, EqualsValueClauseSyntax initializer, BindValueKind valueKind, CSharpSyntaxNode errorSyntax) { if (initializer == null) { if (!errorSyntax.HasErrors) { Error(diagnostics, ErrorCode.ERR_ImplicitlyTypedVariableWithNoInitializer, errorSyntax); } return null; } if (initializer.Value.Kind() == SyntaxKind.ArrayInitializerExpression) { return BindUnexpectedArrayInitializer((InitializerExpressionSyntax)initializer.Value, diagnostics, ErrorCode.ERR_ImplicitlyTypedVariableAssignedArrayInitializer, errorSyntax); } BoundExpression expression = BindValue(initializer.Value, diagnostics, valueKind); // Certain expressions (null literals, method groups and anonymous functions) have no type of // their own and therefore cannot be the initializer of an implicitly typed local. if (!expression.HasAnyErrors && !expression.HasExpressionType()) { // Cannot assign {0} to an implicitly-typed local variable Error(diagnostics, ErrorCode.ERR_ImplicitlyTypedVariableAssignedBadValue, errorSyntax, expression.Display); } return expression; }
public LocalWithInitializer( Symbol containingSymbol, Binder binder, RefKind refKind, TypeSyntax typeSyntax, SyntaxToken identifierToken, EqualsValueClauseSyntax initializer, LocalDeclarationKind declarationKind) : base(containingSymbol, binder, refKind, typeSyntax, identifierToken, declarationKind) { Debug.Assert(declarationKind != LocalDeclarationKind.ForEachIterationVariable); Debug.Assert(initializer != null); _initializer = initializer; // byval locals are always returnable // byref locals with initializers are assumed not returnable unless proven otherwise // NOTE: if we assumed returnable, then self-referring initializer could result in // a randomly changing returnability when initializer is bound concurrently. _returnable = refKind == RefKind.None; }
internal BoundExpression BindInferredVariableInitializer(DiagnosticBag diagnostics, RefKind refKind, EqualsValueClauseSyntax initializer, CSharpSyntaxNode errorSyntax) { BindValueKind valueKind; ExpressionSyntax value; IsInitializerRefKindValid(initializer, initializer, refKind, diagnostics, out valueKind, out value); // The return value isn't important here; we just want the diagnostics and the BindValueKind return BindInferredVariableInitializer(diagnostics, value, valueKind, errorSyntax); }
private static bool EqualsValueClauseNotSuitableForVar( SyntaxToken identifier, TypeSyntax simpleName, EqualsValueClauseSyntax equalsValueClause, SemanticModel semanticModel, CancellationToken cancellationToken) { // var cannot be assigned null if (equalsValueClause.IsKind(SyntaxKind.NullLiteralExpression)) { return true; } var type = semanticModel.GetTypeInfo(simpleName, cancellationToken).Type; // the variable cannot be initialized to a method group or an anonymous function if (type != null && type.TypeKind == TypeKind.Delegate) { return true; } var initializerType = semanticModel.GetTypeInfo(equalsValueClause.Value, cancellationToken).Type; if (!type.Equals(initializerType)) { return true; } // The assign expression in the initializer cannot be the same symbol as the i var possibleSameLocals = equalsValueClause.DescendantNodesAndSelf().Where(n => n.Kind() == SyntaxKind.IdentifierName && ((IdentifierNameSyntax)n).Identifier.ValueText.Equals(identifier.ValueText)); var anyUse = possibleSameLocals.Any(n => { var symbol = semanticModel.GetSymbolInfo(n, cancellationToken).Symbol; if (symbol != null && symbol.Kind == SymbolKind.Local) { return true; } return false; }); if (anyUse) { return true; } return false; }
public override SyntaxNode VisitEqualsValueClause(EqualsValueClauseSyntax node) { this.VisitExpression(node.Value); return node; }
internal abstract bool TryGetSpeculativeSemanticModelCore(SyntaxTreeSemanticModel parentModel, int position, EqualsValueClauseSyntax initializer, out SemanticModel speculativeModel);
/// <summary> /// Get a SemanticModel object that is associated with an initializer that did not appear in /// this source code. This can be used to get detailed semantic information about sub-parts /// of a field initializer or default parameter value that did not appear in source code. /// </summary> /// <param name="position">A character position used to identify a declaration scope and accessibility. This /// character position must be within the FullSpan of the Root syntax node in this SemanticModel. /// </param> /// <param name="initializer">A syntax node that represents a parsed initializer. This initializer should not be /// present in the syntax tree associated with this object.</param> /// <param name="speculativeModel">A SemanticModel object that can be used to inquire about the semantic /// information associated with syntax nodes within <paramref name="initializer"/>.</param> /// <returns>Flag indicating whether a speculative semantic model was created.</returns> /// <exception cref="ArgumentException">Throws this exception if the <paramref name="initializer"/> node is contained any SyntaxTree in the current Compilation.</exception> /// <exception cref="ArgumentNullException">Throws this exception if <paramref name="initializer"/> is null.</exception> /// <exception cref="InvalidOperationException">Throws this exception if this model is a speculative semantic model, i.e. <see cref="SemanticModel.IsSpeculativeSemanticModel"/> is true. /// Chaining of speculative semantic model is not supported.</exception> public bool TryGetSpeculativeSemanticModel(int position, EqualsValueClauseSyntax initializer, out SemanticModel speculativeModel) { CheckModelAndSyntaxNodeToSpeculate(initializer); return TryGetSpeculativeSemanticModelCore((SyntaxTreeSemanticModel)this, position, initializer, out speculativeModel); }
private IEnumerable<ITypeSymbol> InferTypeInEqualsValueClause(EqualsValueClauseSyntax equalsValue, SyntaxToken? previousToken = null) { // If we have a position, it has to be after the = if (previousToken.HasValue && previousToken.Value != equalsValue.EqualsToken) { return SpecializedCollections.EmptyEnumerable<ITypeSymbol>(); } if (equalsValue.IsParentKind(SyntaxKind.VariableDeclarator)) { return InferTypeInVariableDeclarator((VariableDeclaratorSyntax)equalsValue.Parent); } if (equalsValue.IsParentKind(SyntaxKind.Parameter)) { var parameter = this.semanticModel.GetDeclaredSymbol(equalsValue.Parent, cancellationToken) as IParameterSymbol; if (parameter != null) { return SpecializedCollections.SingletonEnumerable(parameter.Type); } } return SpecializedCollections.EmptyEnumerable<ITypeSymbol>(); }
/// <summary> /// Make a local variable symbol which can be inferred (if necessary) by binding its initializing expression. /// </summary> /// <param name="containingSymbol"></param> /// <param name="scopeBinder"> /// Binder that owns the scope for the local, the one that returns it in its <see cref="Binder.Locals"/> array. /// </param> /// <param name="allowRefKind"></param> /// <param name="typeSyntax"></param> /// <param name="identifierToken"></param> /// <param name="declarationKind"></param> /// <param name="initializer"></param> /// <param name="initializerBinderOpt"> /// Binder that should be used to bind initializer, if different from the <paramref name="scopeBinder"/>. /// </param> /// <returns></returns> public static SourceLocalSymbol MakeLocal( Symbol containingSymbol, Binder scopeBinder, bool allowRefKind, TypeSyntax typeSyntax, SyntaxToken identifierToken, LocalDeclarationKind declarationKind, EqualsValueClauseSyntax initializer = null, Binder initializerBinderOpt = null) { Debug.Assert(declarationKind != LocalDeclarationKind.ForEachIterationVariable); return (initializer != null) ? new LocalWithInitializer(containingSymbol, scopeBinder, typeSyntax, identifierToken, initializer, initializerBinderOpt ?? scopeBinder, declarationKind) : new SourceLocalSymbol(containingSymbol, scopeBinder, allowRefKind, typeSyntax, identifierToken, declarationKind); }
internal sealed override bool TryGetSpeculativeSemanticModelCore(SyntaxTreeSemanticModel parentModel, int position, EqualsValueClauseSyntax initializer, out SemanticModel speculativeModel) { position = CheckAndAdjustPosition(position); var model = this.GetMemberModel(position); if (model != null) { return model.TryGetSpeculativeSemanticModelCore(parentModel, position, initializer, out speculativeModel); } speculativeModel = null; return false; }
protected static bool IsInitializerRefKindValid( EqualsValueClauseSyntax initializer, CSharpSyntaxNode node, RefKind variableRefKind, DiagnosticBag diagnostics, out BindValueKind valueKind) { if (variableRefKind == RefKind.None) { valueKind = BindValueKind.RValue; if (initializer != null && initializer.RefKeyword.Kind() != SyntaxKind.None) { Error(diagnostics, ErrorCode.ERR_InitializeByValueVariableWithReference, node); return false; } } else { valueKind = BindValueKind.RefOrOut; if (initializer == null) { Error(diagnostics, ErrorCode.ERR_ByReferenceVariableMustBeInitialized, node); return false; } else if (initializer.RefKeyword.Kind() == SyntaxKind.None) { Error(diagnostics, ErrorCode.ERR_InitializeByReferenceVariableWithValue, node); return false; } } return true; }
public static SourceLocalSymbol MakeLocal( Symbol containingSymbol, Binder binder, RefKind refKind, TypeSyntax typeSyntax, SyntaxToken identifierToken, LocalDeclarationKind declarationKind, EqualsValueClauseSyntax initializer = null) { Debug.Assert(declarationKind != LocalDeclarationKind.ForEachIterationVariable); if (initializer == null) { ArgumentSyntax argument; if (ArgumentSyntax.IsIdentifierOfOutVariableDeclaration(identifierToken, out argument)) { if (argument.Type.IsVar) { return new PossibleOutVarLocalSymbol(containingSymbol, binder, refKind, typeSyntax, identifierToken, declarationKind); } } return new SourceLocalSymbol(containingSymbol, binder, refKind, typeSyntax, identifierToken, declarationKind); } return new LocalWithInitializer(containingSymbol, binder, refKind, typeSyntax, identifierToken, initializer, declarationKind); }
private BoundNode BindEqualsValue(Binder binder, EqualsValueClauseSyntax equalsValue, DiagnosticBag diagnostics) { switch (this.MemberSymbol.Kind) { case SymbolKind.Field: { var enumField = this.MemberSymbol as SourceEnumConstantSymbol; if ((object)enumField != null) { return binder.BindEnumConstantInitializer(enumField, equalsValue.Value, diagnostics); } var fieldType = ((FieldSymbol)this.MemberSymbol).GetFieldType(binder.FieldsBeingBound); return binder.BindVariableOrAutoPropInitializer(equalsValue, fieldType, diagnostics); } case SymbolKind.Property: { var propertyType = ((PropertySymbol)this.MemberSymbol).Type; return binder.BindVariableOrAutoPropInitializer(equalsValue, propertyType, diagnostics); } case SymbolKind.Parameter: { BoundExpression unusedValueBeforeConversion; // not needed. var parameter = (ParameterSymbol)this.MemberSymbol; return binder.BindParameterDefaultValue( equalsValue, parameter.Type, diagnostics, out unusedValueBeforeConversion); } default: Debug.Assert(false, "Unexpected member symbol kind: " + this.MemberSymbol.Kind); return null; } }
public FieldInitializerInfo(FieldInitializer initializer, Binder binder, EqualsValueClauseSyntax equalsValue) { Initializer = initializer; Binder = binder; EqualsValue = equalsValue; }
protected static bool IsInitializerRefKindValid( EqualsValueClauseSyntax initializer, CSharpSyntaxNode node, RefKind variableRefKind, DiagnosticBag diagnostics, out BindValueKind valueKind, out ExpressionSyntax value) { RefKind expressionRefKind = RefKind.None; value = initializer?.Value.SkipRef(out expressionRefKind); if (variableRefKind == RefKind.None) { valueKind = BindValueKind.RValue; if (expressionRefKind == RefKind.Ref) { Error(diagnostics, ErrorCode.ERR_InitializeByValueVariableWithReference, node); return false; } } else { valueKind = BindValueKind.RefOrOut; if (initializer == null) { Error(diagnostics, ErrorCode.ERR_ByReferenceVariableMustBeInitialized, node); return false; } else if (expressionRefKind != RefKind.Ref) { Error(diagnostics, ErrorCode.ERR_InitializeByReferenceVariableWithValue, node); return false; } } return true; }
internal override bool TryGetSpeculativeSemanticModelCore(SyntaxTreeSemanticModel parentModel, int position, EqualsValueClauseSyntax initializer, out SemanticModel speculativeModel) { speculativeModel = null; return false; }
public override void VisitEqualsValueClause(EqualsValueClauseSyntax node) { var valueBinder = new ExpressionVariableBinder(node, _enclosing); AddToMap(node, valueBinder); Visit(node.Value, valueBinder); }