private void HandleParenthesizedExpression(SyntaxNodeAnalysisContext context) { var node = context.Node as ParenthesizedExpressionSyntax; if (node != null && node.Expression != null) { if (!(node.Expression is BinaryExpressionSyntax) && !(node.Expression is AssignmentExpressionSyntax) && !(node.Expression is PrefixUnaryExpressionSyntax) && !(node.Expression is PostfixUnaryExpressionSyntax) && !node.Expression.IsKind(SyntaxKind.CastExpression) && !node.Expression.IsKind(SyntaxKind.ConditionalExpression) && !node.Expression.IsKind(SyntaxKind.IsExpression) && !node.Expression.IsKind(SyntaxKind.SimpleLambdaExpression) && !node.Expression.IsKind(SyntaxKind.ParenthesizedLambdaExpression) && !node.Expression.IsKind(SyntaxKind.ArrayCreationExpression) && !node.Expression.IsKind(SyntaxKind.CoalesceExpression) && !node.Expression.IsKind(SyntaxKind.QueryExpression) && !node.Expression.IsKind(SyntaxKind.AwaitExpression) && !node.IsKind(SyntaxKind.ConstructorDeclaration)) { ReportDiagnostic(context, node); } else { if (!(node.Parent is ExpressionSyntax) || node.Parent is CheckedExpressionSyntax || node.Parent is MemberAccessExpressionSyntax) { var memberAccess = node.Parent as MemberAccessExpressionSyntax; if (memberAccess != null) { if (memberAccess.Expression != node) { ReportDiagnostic(context, node); } } else { ReportDiagnostic(context, node); } } else { EqualsValueClauseSyntax equalsValue = node.Parent as EqualsValueClauseSyntax; if (equalsValue != null && equalsValue.Value == node) { ReportDiagnostic(context, node); } else { AssignmentExpressionSyntax assignValue = node.Parent as AssignmentExpressionSyntax; if (assignValue != null) { ReportDiagnostic(context, node); } } } } } }
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); }
/// <summary> /// Analyzes the assignment expression and rejects a given declaration if it is unsuitable for explicit typing. /// </summary> /// <returns> /// false, if explicit typing cannot be used. /// true, otherwise. /// </returns> protected override bool AssignmentSupportsStylePreference(SyntaxToken identifier, TypeSyntax typeName, EqualsValueClauseSyntax initializer, SemanticModel semanticModel, OptionSet optionSet, CancellationToken cancellationToken) { // is or contains an anonymous type // cases : // var anon = new { Num = 1 }; // var enumerableOfAnons = from prod in products select new { prod.Color, prod.Price }; var declaredType = semanticModel.GetTypeInfo(typeName, cancellationToken).Type; if (declaredType.ContainsAnonymousType()) { return(false); } // cannot find type if initializer resolves to an ErrorTypeSymbol var initializerTypeInfo = semanticModel.GetTypeInfo(initializer.Value, cancellationToken); return(!initializerTypeInfo.Type.IsErrorType()); }
internal override bool TryGetSpeculativeSemanticModelCore(SyntaxTreeSemanticModel parentModel, int position, EqualsValueClauseSyntax initializer, out SemanticModel?speculativeModel) { speculativeModel = null; return(false); }
private void ProcessEnum([NotNull] EnumDeclarationSyntax enumDecl, NamespaceDeclarationSyntax namespaceDecl = null) { if (enumDecl == null) { throw new ArgumentNullException(nameof(enumDecl)); } ModelRoot modelRoot = Store.ModelRoot(); string enumName = enumDecl.Identifier.Text; if (namespaceDecl == null && enumDecl.Parent is NamespaceDeclarationSyntax enumDeclParent) { namespaceDecl = enumDeclParent; } string namespaceName = namespaceDecl?.Name?.ToString() ?? modelRoot.Namespace; if (Store.Get <ModelClass>().Any(c => c.Name == enumName) || Store.Get <ModelEnum>().Any(c => c.Name == enumName)) { ErrorDisplay.Show($"'{enumName}' already exists in model."); // ReSharper disable once ExpressionIsAlwaysNull return; } Transaction tx = Store.TransactionManager.CurrentTransaction == null ? Store.TransactionManager.BeginTransaction() : null; try { ModelEnum result = new ModelEnum(Store, new PropertyAssignment(ModelEnum.NameDomainPropertyId, enumName)) { Namespace = namespaceName, IsFlags = enumDecl.HasAttribute("Flags") }; SimpleBaseTypeSyntax baseTypeSyntax = enumDecl.DescendantNodes().OfType <SimpleBaseTypeSyntax>().FirstOrDefault(); if (baseTypeSyntax != null) { switch (baseTypeSyntax.Type.ToString()) { case "Int16": case "short": result.ValueType = EnumValueType.Int16; break; case "Int32": case "int": result.ValueType = EnumValueType.Int32; break; case "Int64": case "long": result.ValueType = EnumValueType.Int64; break; default: WarningDisplay.Show($"Could not resolve value type for '{enumName}'. The enum will default to an Int32 value type."); break; } } XMLDocumentation xmlDocumentation; foreach (EnumMemberDeclarationSyntax enumValueDecl in enumDecl.DescendantNodes().OfType <EnumMemberDeclarationSyntax>()) { ModelEnumValue enumValue = new ModelEnumValue(Store, new PropertyAssignment(ModelEnumValue.NameDomainPropertyId, enumValueDecl.Identifier.ToString())); EqualsValueClauseSyntax valueDecl = enumValueDecl.DescendantNodes().OfType <EqualsValueClauseSyntax>().FirstOrDefault(); if (valueDecl != null) { enumValue.Value = valueDecl.Value.ToString(); } xmlDocumentation = new XMLDocumentation(enumValueDecl); enumValue.Summary = xmlDocumentation.Summary; enumValue.Description = xmlDocumentation.Description; result.Values.Add(enumValue); } xmlDocumentation = new XMLDocumentation(enumDecl); result.Summary = xmlDocumentation.Summary; result.Description = xmlDocumentation.Description; modelRoot.Enums.Add(result); } catch { tx = null; throw; } finally { tx?.Commit(); } }
public static Task <Document> RefactorAsync(Document document, IfAnalysis ifAnalysis, CancellationToken cancellationToken = default) { switch (ifAnalysis.Kind) { case IfAnalysisKind.IfElseToAssignmentWithCoalesceExpression: { return(IfElseToAssignmentWithCoalesceExpressionAsync(document, (IfElseToAssignmentWithCoalesceExpressionAnalysis)ifAnalysis, cancellationToken)); } case IfAnalysisKind.IfElseToAssignmentWithConditionalExpression: { return(IfElseToAssignmentWithConditionalExpressionAsync(document, (IfElseToAssignmentWithConditionalExpressionAnalysis)ifAnalysis, cancellationToken)); } case IfAnalysisKind.AssignmentAndIfToAssignmentWithConditionalExpression: { var analysis = (AssignmentAndIfToAssignmentWithConditionalExpressionAnalysis)ifAnalysis; ConditionalExpressionSyntax conditionalExpression = CreateConditionalExpression(analysis.IfStatement.Condition, analysis.WhenTrue, analysis.WhenFalse); ExpressionStatementSyntax newStatement = analysis.Statement.ReplaceNode(analysis.Right, conditionalExpression); return(ToAssignmentWithConditionalExpressionAsync(document, analysis, newStatement, cancellationToken)); } case IfAnalysisKind.LocalDeclarationAndIfElseAssignmentWithConditionalExpression: { var analysis = (LocalDeclarationAndIfElseToAssignmentWithConditionalExpressionAnalysis)ifAnalysis; ConditionalExpressionSyntax conditionalExpression = CreateConditionalExpression(analysis.IfStatement.Condition, analysis.WhenTrue, analysis.WhenFalse); VariableDeclaratorSyntax declarator = analysis.Statement.Declaration.Variables[0]; EqualsValueClauseSyntax initializer = declarator.Initializer; EqualsValueClauseSyntax newInitializer = (initializer != null) ? initializer.WithValue(conditionalExpression) : EqualsValueClause(conditionalExpression); LocalDeclarationStatementSyntax newStatement = analysis.Statement.ReplaceNode(declarator, declarator.WithInitializer(newInitializer)); return(ToAssignmentWithConditionalExpressionAsync(document, analysis, newStatement, cancellationToken)); } case IfAnalysisKind.IfElseToAssignmentWithExpression: { return(IfElseToAssignmentWithExpressionAsync(document, (IfElseToAssignmentWithExpressionAnalysis)ifAnalysis, cancellationToken)); } case IfAnalysisKind.IfElseToAssignmentWithCondition: { return(IfElseToAssignmentWithConditionAsync(document, (IfElseToAssignmentWithConditionAnalysis)ifAnalysis, cancellationToken)); } case IfAnalysisKind.IfElseToReturnWithCoalesceExpression: case IfAnalysisKind.IfElseToYieldReturnWithCoalesceExpression: case IfAnalysisKind.IfReturnToReturnWithCoalesceExpression: { return(IfToReturnWithCoalesceExpressionAsync(document, (IfToReturnWithCoalesceExpressionAnalysis)ifAnalysis, cancellationToken)); } case IfAnalysisKind.IfElseToReturnWithConditionalExpression: { return(IfElseToReturnWithConditionalExpressionAsync(document, (IfElseToReturnWithConditionalExpressionAnalysis)ifAnalysis, cancellationToken)); } case IfAnalysisKind.IfElseToReturnWithBooleanExpression: { return(IfElseToReturnWithBooleanExpressionAsync(document, (IfElseToReturnWithBooleanExpressionAnalysis)ifAnalysis, cancellationToken)); } case IfAnalysisKind.IfElseToReturnWithExpression: case IfAnalysisKind.IfElseToYieldReturnWithExpression: case IfAnalysisKind.IfReturnToReturnWithExpression: { return(IfToReturnWithExpressionAsync(document, (IfToReturnWithExpressionAnalysis)ifAnalysis, cancellationToken)); } case IfAnalysisKind.IfElseToYieldReturnWithConditionalExpression: { return(IfElseToYieldReturnWithConditionalExpressionAsync(document, (IfElseToYieldReturnWithConditionalExpressionAnalysis)ifAnalysis, cancellationToken)); } case IfAnalysisKind.IfElseToYieldReturnWithBooleanExpression: { return(IfElseToYieldReturnWithBooleanExpressionAsync(document, (IfElseToYieldReturnWithBooleanExpressionAnalysis)ifAnalysis, cancellationToken)); } case IfAnalysisKind.IfReturnToReturnWithConditionalExpression: { return(IfReturnToReturnWithConditionalExpressionAsync(document, (IfReturnToReturnWithConditionalExpressionAnalysis)ifAnalysis, cancellationToken)); } case IfAnalysisKind.IfReturnToReturnWithBooleanExpression: { return(IfReturnToReturnWithBooleanExpressionAsync(document, (IfReturnToReturnWithBooleanExpressionAnalysis)ifAnalysis, cancellationToken)); } default: { throw new InvalidOperationException(); } } }
public EqualsValueClauseTranslation(EqualsValueClauseSyntax syntax, SyntaxTranslation parent) : base(syntax, parent) { Value = syntax.Value.Get <ExpressionTranslation>(this); }
private static bool CheckDefaultExpressionInitializer(EqualsValueClauseSyntax initializer) { var defaultValue = initializer.Value as DefaultExpressionSyntax; return(defaultValue != null); }
public sealed override void VisitEqualsValueClause(EqualsValueClauseSyntax syntax) { this.Visit(syntax.Value); }
public override SyntaxNode VisitEqualsValueClause(EqualsValueClauseSyntax node) { node = (EqualsValueClauseSyntax)base.VisitEqualsValueClause(node); Classes.Add(node); return(node); }
internal static async Task ComputeRefactoringAsync(RefactoringContext context, LocalDeclarationStatementSyntax localDeclarationStatement) { EqualsValueClauseSyntax equalsValueClause = localDeclarationStatement .Declaration .Variables .SingleOrDefault(shouldThrow: false)? .Initializer; if (equalsValueClause == null) { return; } if (!context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(equalsValueClause)) { return; } ExpressionSyntax value = equalsValueClause.Value; if (value == null) { return; } const string title = "Remove instantiation"; switch (value) { case ObjectCreationExpressionSyntax objectCreation: { InitializerExpressionSyntax initializer = objectCreation.Initializer; if (initializer?.Span.Contains(context.Span) == true) { return; } SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(objectCreation, context.CancellationToken); ComputeRefactoring(context, title, typeSymbol, localDeclarationStatement, value); break; } case ArrayCreationExpressionSyntax arrayCreation: { InitializerExpressionSyntax initializer = arrayCreation.Initializer; if (initializer?.Span.Contains(context.Span) == true) { return; } SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(arrayCreation, context.CancellationToken); ComputeRefactoring(context, title, typeSymbol, localDeclarationStatement, value); break; } case ImplicitArrayCreationExpressionSyntax implicitArrayCreation: { InitializerExpressionSyntax initializer = implicitArrayCreation.Initializer; if (initializer?.Span.Contains(context.Span) == true) { return; } SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(implicitArrayCreation, context.CancellationToken); ComputeRefactoring(context, title, typeSymbol, localDeclarationStatement, value); break; } } }
private static BoundFieldEqualsValue BindFieldInitializer(Binder binder, FieldSymbol fieldSymbol, EqualsValueClauseSyntax equalsValueClauseNode, DiagnosticBag diagnostics) { Debug.Assert(!fieldSymbol.IsMetadataConstant); var fieldsBeingBound = binder.FieldsBeingBound; var sourceField = fieldSymbol as SourceMemberFieldSymbolFromDeclarator; 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; } binder = new ExecutableCodeBinder(equalsValueClauseNode, fieldSymbol, new LocalScopeBinder(binder)); BoundFieldEqualsValue boundInitValue = binder.BindFieldInitializer(fieldSymbol, equalsValueClauseNode, initializerDiagnostics); if (isImplicitlyTypedField) { initializerDiagnostics.Free(); } return(boundInitValue); }
protected abstract void CompileEqualsValueClause(EqualsValueClauseSyntax clause);
public void VisitEqualsValueClause(EqualsValueClauseSyntax node) { if (node == null) throw new ArgumentNullException("node"); node.Validate(); _writer.WriteSpace(); _writer.WriteOperator(PrinterOperator.Equals); _writer.WriteSpace(); node.Value.Accept(this); }
public static NewStatementSyntax SetStatement(string variableName, NewExpressionSyntax arrayIndex, EqualsValueClauseSyntax equalsValueClause) { return(new NewStatementSyntax( new StatementSyntax( new SetStatementSyntax( new TokenNode(new SyntaxToken(SyntaxTokenType.SetKeyword), 0), new TokenNode(new SyntaxToken(SyntaxTokenType.AlphanumericIdentifier, variableName), 0), new BracketedExpressionSyntax( new TokenNode(new SyntaxToken(SyntaxTokenType.SquareBracketOpenSymbol), 0), arrayIndex, new TokenNode(new SyntaxToken(SyntaxTokenType.SquareBracketCloseSymbol), 0)), equalsValueClause)), new LineDelimiterSyntax(new EndOfLineSyntax(new TokenNode(new SyntaxToken(SyntaxTokenType.NewlineSymbol), 0))))); }
public virtual void VisitEqualsValueClause(EqualsValueClauseSyntax node) { DefaultVisit(node); }
private void AnalyzeNode(SyntaxNodeAnalysisContext context) { // <SnippetLocalDeclaration> var localDeclaration = (LocalDeclarationStatementSyntax)context.Node; // </SnippetLocalDeclaration> // <SnippetBailOutOnConst> // make sure the declaration isn't already const: if (localDeclaration.Modifiers.Any(SyntaxKind.ConstKeyword)) { return; } // </SnippetBailOutOnConst> // <SnippetVariableConvertedType> TypeSyntax variableTypeName = localDeclaration.Declaration.Type; ITypeSymbol variableType = context.SemanticModel.GetTypeInfo(variableTypeName, context.CancellationToken).ConvertedType; // </SnippetVariableConvertedType> // Ensure that all variables in the local declaration have initializers that // are assigned with constant values. foreach (VariableDeclaratorSyntax variable in localDeclaration.Declaration.Variables) { EqualsValueClauseSyntax initializer = variable.Initializer; if (initializer == null) { return; } Optional <object> constantValue = context.SemanticModel.GetConstantValue(initializer.Value, context.CancellationToken); if (!constantValue.HasValue) { return; } // <SnippetBailOutOnUserDefinedConversion> // Ensure that the initializer value can be converted to the type of the // local declaration without a user-defined conversion. Conversion conversion = context.SemanticModel.ClassifyConversion(initializer.Value, variableType); if (!conversion.Exists || conversion.IsUserDefined) { return; } // </SnippetBailOutOnUserDefinedConversion> // <SnippetHandleSpecialCases> // Special cases: // * If the constant value is a string, the type of the local declaration // must be System.String. // * If the constant value is null, the type of the local declaration must // be a reference type. if (constantValue.Value is string) { if (variableType.SpecialType != SpecialType.System_String) { return; } } else if (variableType.IsReferenceType && constantValue.Value != null) { return; } // </SnippetHandleSpecialCases> } // Perform data flow analysis on the local declaration. DataFlowAnalysis dataFlowAnalysis = context.SemanticModel.AnalyzeDataFlow(localDeclaration); foreach (VariableDeclaratorSyntax variable in localDeclaration.Declaration.Variables) { // Retrieve the local symbol for each variable in the local declaration // and ensure that it is not written outside of the data flow analysis region. ISymbol variableSymbol = context.SemanticModel.GetDeclaredSymbol(variable, context.CancellationToken); if (dataFlowAnalysis.WrittenOutside.Contains(variableSymbol)) { return; } } // <SnippetReportDiagnostic> context.ReportDiagnostic(Diagnostic.Create(Rule, context.Node.GetLocation(), localDeclaration.Declaration.Variables.First().Identifier.ValueText)); // </SnippetReportDiagnostic> }
private static bool CheckReferenceTypeNullInitializer(EqualsValueClauseSyntax initializer, ITypeSymbol type) { return(type.IsReferenceType && CSharpEquivalenceChecker.AreEquivalent(CSharpSyntaxHelper.NullLiteralExpression, initializer.Value)); }
protected abstract bool AssignmentSupportsStylePreference(SyntaxToken identifier, TypeSyntax typeName, EqualsValueClauseSyntax initializer, SemanticModel semanticModel, OptionSet optionSet, CancellationToken cancellationToken);
public override string VisitEqualsValueClause(EqualsValueClauseSyntax node) { return(node.EqualsToken.ToFullString() + Visit(node.Value)); }
protected static ExpressionSyntax GetInitializerExpression(EqualsValueClauseSyntax initializer) => initializer.Value is CheckedExpressionSyntax ? ((CheckedExpressionSyntax)initializer.Value).Expression.WalkDownParentheses() : initializer.Value.WalkDownParentheses();
private BoundEqualsValue BindEqualsValue(EqualsValueClauseSyntax syntax) { return(new BoundEqualsValue(Bind(syntax.Value, BindExpression))); }
internal override bool TryGetSpeculativeSemanticModelCore(SyntaxTreeSemanticModel parentModel, int position, EqualsValueClauseSyntax initializer, out SemanticModel speculativeModel) { return(TryGetSpeculativeSemanticModelCore(parentModel, position, initializer, out speculativeModel)); }
// 赋初值 public virtual void VisitEqualsValueClauseSyntax(EqualsValueClauseSyntax value) { DefaultVisit(value); }
// // Summary: // Called when the visitor visits a EqualsValueClauseSyntax node. public virtual void VisitEqualsValueClause(EqualsValueClauseSyntax node);
public override void VisitEqualsValueClause(EqualsValueClauseSyntax node) { VisitNodeToBind(node.Value); }
internal override bool TryGetSpeculativeSemanticModelCore(SyntaxTreeSemanticModel parentModel, int position, EqualsValueClauseSyntax initializer, out SemanticModel speculativeModel) { var binder = this.GetEnclosingBinder(position); if (binder == null) { speculativeModel = null; return(false); } binder = new ExecutableCodeBinder(initializer, binder.ContainingMemberOrLambda, binder); speculativeModel = CreateSpeculative(parentModel, this.MemberSymbol, initializer, binder, GetRemappedSymbols(), position); return(true); }
public override void VisitEqualsValueClause(EqualsValueClauseSyntax node) { base.VisitEqualsValueClause(node); }
public static void Analyze(SyntaxNodeAnalysisContext context, EqualsValueClauseSyntax equalsValueClause) { AnalyzeExpression(context, equalsValueClause.Value); }
public override Ust VisitEqualsValueClause(EqualsValueClauseSyntax node) { throw new InvalidOperationException(); }
internal static bool IsDefaultValueInitializer(EqualsValueClauseSyntax initializer, ITypeSymbol type) { return(CheckDefaultExpressionInitializer(initializer) || CheckReferenceTypeNullInitializer(initializer, type) || CheckValueTypeDefaultValueInitializer(initializer, type)); }
private VariableDeclaratorSyntax ParseVariableDeclarator(TypeSyntax parentType, bool isExpressionContext = false) { if (!isExpressionContext) { // Check for the common pattern of: // // C //<-- here // Console.WriteLine(); // // Standard greedy parsing will assume that this should be parsed as a variable // declaration: "C Console". We want to avoid that as it can confused parts of the // system further up. So, if we see certain things following the identifier, then we can // assume it's not the actual name. // // So, if we're after a newline and we see a name followed by the list below, then we // assume that we're accidently consuming too far into the next statement. // // <dot>, <arrow>, any binary operator (except =), <question>. None of these characters // are allowed in a normal variable declaration. This also provides a more useful error // message to the user. Instead of telling them that a semicolon is expected after the // following token, then instead get a useful message about an identifier being missing. // The above list prevents: // // C //<-- here // Console.WriteLine(); // // C //<-- here // Console->WriteLine(); // // C // A + B; // etc. // // C // A ? B : D; var resetPoint = GetResetPoint(); try { var currentTokenKind = Current.Kind; if (currentTokenKind == SyntaxKind.IdentifierToken && !parentType.IsMissing) { var isAfterNewLine = parentType.GetLastToken().TrailingTrivia.Any(t => t.Kind == SyntaxKind.EndOfLineTrivia); if (isAfterNewLine) { NextToken(); currentTokenKind = Current.Kind; var isNonEqualsBinaryToken = currentTokenKind != SyntaxKind.EqualsToken && SyntaxFacts.IsBinaryExpression(currentTokenKind); if (currentTokenKind == SyntaxKind.DotToken || isNonEqualsBinaryToken) { var missingIdentifier = InsertMissingToken(SyntaxKind.IdentifierToken); return new VariableDeclaratorSyntax(missingIdentifier, new List<ArrayRankSpecifierSyntax>(), new List<VariableDeclaratorQualifierSyntax>(), null, null); } } } } finally { Reset(ref resetPoint); } } var name = Match(SyntaxKind.IdentifierToken); var arrayRankSpecifiers = new List<ArrayRankSpecifierSyntax>(); if (Current.Kind == SyntaxKind.OpenBracketToken) ParseArrayRankSpecifiers(arrayRankSpecifiers, false); var qualifiers = new List<VariableDeclaratorQualifierSyntax>(); while (Current.Kind == SyntaxKind.ColonToken) { if (IsPossibleVariableDeclaratorQualifier(Lookahead)) { qualifiers.Add(ParseVariableDeclaratorQualifier()); } else { var action = SkipBadTokens( p => !p.IsPossibleVariableDeclaratorQualifier(Current), p => p.Current.Kind == SyntaxKind.EqualsToken || p.Current.Kind == SyntaxKind.OpenBraceToken || p.IsTerminator(), SyntaxKind.RegisterKeyword); if (action == PostSkipAction.Abort) break; } } AnnotationsSyntax annotations = null; if (Current.Kind == SyntaxKind.LessThanToken) annotations = ParseAnnotations(); InitializerSyntax initializer = null; if (Current.Kind == SyntaxKind.EqualsToken) { if (Lookahead.Kind == SyntaxKind.SamplerStateLegacyKeyword) { initializer = ParseSamplerStateInitializer(); } else { var equals = NextToken(); var init = ParseVariableInitializer(); initializer = new EqualsValueClauseSyntax(equals, init); } } else if (Current.Kind == SyntaxKind.OpenBraceToken) { if (Lookahead.Kind == SyntaxKind.OpenBraceToken) initializer = ParseStateArrayInitializer(); else initializer = ParseStateInitializer(); } return new VariableDeclaratorSyntax(name, arrayRankSpecifiers, qualifiers, annotations, initializer); }
private static bool CheckDefaultExpressionInitializer(EqualsValueClauseSyntax initializer) { return(initializer.Value is DefaultExpressionSyntax defaultValue); }
private string EmitExpression(EqualsValueClauseSyntax node) { var result = new StringBuilder(); result.Append("= "); result.Append(EmitExpression(node.Value)); return result.ToString(); }
/// <summary> /// Analyzes the assignment expression and rejects a given declaration if it is unsuitable for implicit typing. /// </summary> /// <returns> /// false, if implicit typing cannot be used. /// true, otherwise. /// </returns> protected override bool AssignmentSupportsStylePreference(SyntaxToken identifier, TypeSyntax typeName, EqualsValueClauseSyntax initializer, SemanticModel semanticModel, OptionSet optionSet, CancellationToken cancellationToken) { var expression = GetInitializerExpression(initializer); // var cannot be assigned null if (expression.IsKind(SyntaxKind.NullLiteralExpression)) { return(false); } // cannot use implicit typing on method group, anonymous function or on dynamic var declaredType = semanticModel.GetTypeInfo(typeName, cancellationToken).Type; if (declaredType != null && (declaredType.TypeKind == TypeKind.Delegate || declaredType.TypeKind == TypeKind.Dynamic)) { return(false); } // variables declared using var cannot be used further in the same initialization expression. if (initializer.DescendantNodesAndSelf() .Where(n => (n as IdentifierNameSyntax)?.Identifier.ValueText.Equals(identifier.ValueText) == true) .Any(n => semanticModel.GetSymbolInfo(n, cancellationToken).Symbol?.IsKind(SymbolKind.Local) == true)) { return(false); } // Get the conversion that occurred between the expression's type and type implied by the expression's context // and filter out implicit conversions. If an implicit conversion (other than identity) exists // and if we're replacing the declaration with 'var' we'd be changing the semantics by inferring type of // initializer expression and thereby losing the conversion. var conversion = semanticModel.GetConversion(expression, cancellationToken); if (conversion.Exists && conversion.IsImplicit && !conversion.IsIdentity) { return(false); } // final check to compare type information on both sides of assignment. var initializerType = semanticModel.GetTypeInfo(expression, cancellationToken).Type; return(declaredType.Equals(initializerType)); }