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