public override void VisitVariableDeclaration(VariableDeclarationSyntax node)
{
// start with variable type
if (node.Type.IsVar)
{
// no idea
cb.AppendWithIndent("auto ");
}
else
{
var si = model.GetSymbolInfo(node.Type);
ITypeSymbol ts = (ITypeSymbol) si.Symbol;
cb.AppendWithIndent(ts.ToCppType()).Append(" ");
}
// now comes the name(s)
for (int i = 0; i < node.Variables.Count; ++i)
{
var v = node.Variables[i];
cb.Append(v.Identifier.Text);
if (v.Initializer != null)
{
cb.Append(" = ");
v.Initializer.Accept(this);
}
cb.AppendLine(i + 1 == node.Variables.Count ? ";" : ",");
}
}
public static string VariableDeclaration(VariableDeclarationSyntax declaration)
{
var isConst = declaration.Parent is LocalDeclarationStatementSyntax
&& ((LocalDeclarationStatementSyntax) declaration.Parent).IsConst;
var output = isConst ? "let " : "var ";
foreach (var currVar in declaration.Variables)
{
output += currVar.Identifier.Text;
if (!declaration.Type.IsVar)
{
output += ": " + SyntaxNode(declaration.Type);
}
if (currVar.Initializer != null)
{
output += " " + SyntaxNode(currVar.Initializer);
}
output += ", ";
}
return output.TrimEnd(',', ' ');
}
private bool IsReportable(VariableDeclarationSyntax variableDeclaration, SemanticModel semanticModel)
{
bool result;
TypeSyntax variableTypeName = variableDeclaration.Type;
if (variableTypeName.IsVar)
{
// Implicitly-typed variables cannot have multiple declarators. Short circuit if it does.
bool hasMultipleVariables = variableDeclaration.Variables.Skip(1).Any();
if(hasMultipleVariables == false)
{
// Special case: Ensure that 'var' isn't actually an alias to another type. (e.g. using var = System.String).
IAliasSymbol aliasInfo = semanticModel.GetAliasInfo(variableTypeName);
if (aliasInfo == null)
{
// Retrieve the type inferred for var.
ITypeSymbol type = semanticModel.GetTypeInfo(variableTypeName).ConvertedType;
// Special case: Ensure that 'var' isn't actually a type named 'var'.
if (type.Name.Equals("var", StringComparison.Ordinal) == false)
{
// Special case: Ensure that the type is not an anonymous type.
if (type.IsAnonymousType == false)
{
// Special case: Ensure that it's not a 'new' expression.
if (variableDeclaration.Variables.First().Initializer.Value.IsKind(SyntaxKind.ObjectCreationExpression))
{
result = false;
}
else
{
result = true;
}
}
else
{
result = false;
}
}
else
{
result = false;
}
}
else
{
result = false;
}
}
else
{
result = false;
}
}
else
{
result = false;
}
return result;
}
/// <summary>
/// Returns true if type information could be gleaned by simply looking at the given statement.
/// This typically means that the type name occurs in right hand side of an assignment.
/// </summary>
private bool IsTypeApparentInDeclaration(VariableDeclarationSyntax variableDeclaration, SemanticModel semanticModel, TypeStylePreference stylePreferences, CancellationToken cancellationToken)
{
var initializer = variableDeclaration.Variables.Single().Initializer;
var initializerExpression = GetInitializerExpression(initializer);
var declaredTypeSymbol = semanticModel.GetTypeInfo(variableDeclaration.Type, cancellationToken).Type;
return TypeStyleHelper.IsTypeApparentInAssignmentExpression(stylePreferences, initializerExpression, semanticModel,cancellationToken, declaredTypeSymbol);
}
public static void Go(OutputWriter writer, VariableDeclarationSyntax declaration)
{
foreach (var variable in declaration.Variables)
{
ISymbol symbol = TypeProcessor.GetDeclaredSymbol(variable);
var isRef = false; //UsedAsRef(variable, symbol);
writer.WriteIndent();
// writer.Write("var ");
// if (isRef) //Not needed c++ can passby ref
// {
//
// var typeStr = TypeProcessor.ConvertType(declaration.Declaration.Type);
//
// var localSymbol = symbol as ILocalSymbol;
// var ptr = localSymbol != null && !localSymbol.Type.IsValueType?"*" : "";
// writer.Write("gc::gc_ptr < " + typeStr+ ptr + " >");
// writer.Write("" + typeStr + ptr + "");
//
// writer.Write(" ");
// writer.Write(WriteIdentifierName.TransformIdentifier(variable.Identifier.Text));
//
// Program.RefOutSymbols.TryAdd(symbol, null);
//
// writer.Write(" = std::make_shared < ");
// writer.Write(typeStr + ptr);
// writer.Write(" >(");
//
// WriteInitializer(writer, declaration, variable);
//
// writer.Write(")");
// }
// else
{
var lsymbol = symbol as ILocalSymbol;
if (lsymbol != null && lsymbol.Type.IsValueType == false)
{
writer.Write(" ");
// Ideally Escape analysis should take care of this, but for now all value types are on heap and ref types on stack
}
writer.Write(TypeProcessor.ConvertType(declaration.Type));
if (lsymbol != null && lsymbol.Type.IsValueType == false)
writer.Write(" ");
writer.Write(" ");
writer.Write(WriteIdentifierName.TransformIdentifier(variable.Identifier.Text));
writer.Write(" = ");
WriteInitializer(writer, declaration, variable);
}
writer.Write(";\r\n");
}
}
public ArgumentSyntax WithDeclaration(VariableDeclarationSyntax declaration)
{
if (this.RefOrOutKeyword.Kind() != SyntaxKind.OutKeyword)
{
throw new InvalidOperationException();
}
return this.WithExpressionOrDeclaration(declaration);
}
public static glsl.VariableDeclarationSyntax Translate(this cs.VariableDeclarationSyntax node)
{
return(new glsl.VariableDeclarationSyntax()
{
Type = new glsl.TypeSyntax()
{
Name = model.GetSymbolInfo(node.Type).Symbol.Name
},
Variables = node.Variables.Select(v => v.Translate()).ToList()
});
}
private async Task<Solution> RemoveHungarianPrefix(Document document, VariableDeclarationSyntax token, CancellationToken cancellationToken)
{
var identifierToken = token.Variables.First();
var newName = DehungarianAnalyzer.SuggestDehungarianName(identifierToken.Identifier.Text);
var semanticModel = await document.GetSemanticModelAsync(cancellationToken);
var tokenSymbol = semanticModel.GetDeclaredSymbol(token.Variables.First(), cancellationToken);
var originalSolution = document.Project.Solution;
var optionSet = originalSolution.Workspace.Options;
var newSolution = await Renamer.RenameSymbolAsync(document.Project.Solution, tokenSymbol, newName, optionSet, cancellationToken).ConfigureAwait(false);
return newSolution;
}
static bool TryValidateLocalVariableType(LocalDeclarationStatementSyntax localDeclarationStatementSyntax, VariableDeclarationSyntax variableDeclarationSyntax)
{
//Either we don't have a local variable or we're using constant value
if (localDeclarationStatementSyntax == null ||
localDeclarationStatementSyntax.IsConst ||
localDeclarationStatementSyntax.ChildNodes().OfType<VariableDeclarationSyntax>().Count() != 1)
return false;
//We don't want to raise a diagnostic if the local variable is already a var
return !variableDeclarationSyntax.Type.IsVar;
}
private async Task<Document> ChangeToFunc(Document document, VariableDeclarationSyntax variableDeclaration, CancellationToken cancellationToken)
{
// Change the variable declaration
var newDeclaration = variableDeclaration.WithType(SyntaxFactory.ParseTypeName("System.Func<System.Threading.Tasks.Task>").WithAdditionalAnnotations(Simplifier.Annotation, Formatter.Annotation)
.WithLeadingTrivia(variableDeclaration.Type.GetLeadingTrivia()).WithTrailingTrivia(variableDeclaration.Type.GetTrailingTrivia()));
var oldRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var newRoot = oldRoot.ReplaceNode(variableDeclaration, newDeclaration);
var newDocument = document.WithSyntaxRoot(newRoot);
// Return document with transformed tree.
return newDocument;
}
private async Task<Document> MakeStaticDeclarationImplicit(Document document,
VariableDeclarationSyntax variableDeclaration, CancellationToken
cancellationToken)
{
var newVariableDeclaration = variableDeclaration.WithType(SyntaxFactory.IdentifierName("var"));
newVariableDeclaration = newVariableDeclaration.WithAdditionalAnnotations(Formatter.Annotation);
var oldRoot = await document.GetSyntaxRootAsync(cancellationToken);
var newRoot = oldRoot.ReplaceNode(variableDeclaration, newVariableDeclaration);
return document.WithSyntaxRoot(newRoot);
}
public VariableDeclarationTranslation(VariableDeclarationSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
Type = syntax.Type.Get<TypeTranslation>(this);
Variables = syntax.Variables.Get<VariableDeclaratorSyntax, VariableDeclaratorTranslation>(this);
if (!syntax.Type.IsVar)
{
Variables.GetEnumerable().First().FirstType = Type;
}
foreach (var item in Variables.GetEnumerable())
{
item.KnownType = Type;
}
}
private async static Task<Document> UseVarAsync(Document document, Diagnostic diagnostic, CancellationToken cancellationToken)
{
var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var diagnosticSpan = diagnostic.Location.SourceSpan;
var localDeclaration = root.FindToken(diagnosticSpan.Start).Parent.AncestorsAndSelf().OfType<LocalDeclarationStatementSyntax>().First();
var variableDeclaration = localDeclaration.Declaration;
var numVariables = variableDeclaration.Variables.Count;
var newVariableDeclarations = new VariableDeclarationSyntax[numVariables];
var varSyntax = SyntaxFactory.IdentifierName("var");
//Create a new var declaration for each variable.
for (var i = 0; i < numVariables; i++)
{
var originalVariable = variableDeclaration.Variables[i];
var newLeadingTrivia = originalVariable.GetLeadingTrivia();
//Get the trivia from the separator as well
if (i != 0)
{
newLeadingTrivia = newLeadingTrivia.InsertRange(0,
variableDeclaration.Variables.GetSeparator(i-1).GetAllTrivia());
}
newVariableDeclarations[i] = SyntaxFactory.VariableDeclaration(varSyntax)
.AddVariables(originalVariable.WithLeadingTrivia(newLeadingTrivia));
}
//ensure trivia for leading type node is preserved
var originalTypeSyntax = variableDeclaration.Type;
newVariableDeclarations[0] = newVariableDeclarations[0]
.WithType((TypeSyntax) varSyntax.WithSameTriviaAs(originalTypeSyntax));
var newLocalDeclarationStatements = newVariableDeclarations.Select(SyntaxFactory.LocalDeclarationStatement).ToList();
//Preserve the trivia for the entire statement at the start and at the end
newLocalDeclarationStatements[0] =
newLocalDeclarationStatements[0].WithLeadingTrivia(variableDeclaration.GetLeadingTrivia());
var lastIndex = numVariables -1;
newLocalDeclarationStatements[lastIndex] =
newLocalDeclarationStatements[lastIndex].WithTrailingTrivia(localDeclaration.GetTrailingTrivia());
var newRoot = root.ReplaceNode(localDeclaration, newLocalDeclarationStatements);
var newDocument = document.WithSyntaxRoot(newRoot);
return newDocument;
}
/// <summary>Creates a new ForStatementSyntax instance.</summary>
public static ForStatementSyntax ForStatement(SyntaxToken forKeyword, SyntaxToken openParenToken, VariableDeclarationSyntax declaration, SeparatedSyntaxList<ExpressionSyntax> initializers, SyntaxToken firstSemicolonToken, ExpressionSyntax condition, SyntaxToken secondSemicolonToken, SeparatedSyntaxList<ExpressionSyntax> incrementors, SyntaxToken closeParenToken, StatementSyntax statement)
{
return ForStatement(
forKeyword: forKeyword,
openParenToken: openParenToken,
refKeyword: default(SyntaxToken),
deconstruction: null,
declaration: declaration,
initializers: initializers,
firstSemicolonToken: firstSemicolonToken,
condition: condition,
secondSemicolonToken: secondSemicolonToken,
incrementors: incrementors,
closeParenToken: closeParenToken,
statement: statement);
}
private static void AnalyzeVariableDeclaration(OperationAnalysisContext context, IVariableDeclarationOperation variableDeclaration)
{
foreach (var declarator in variableDeclaration.Declarators)
{
if (IsInternal(context, declarator.Symbol.Type))
{
var syntax = context.Operation.Syntax switch
{
CSharpSyntax.VariableDeclarationSyntax s => s.Type,
_ => context.Operation.Syntax
};
context.ReportDiagnostic(Diagnostic.Create(_descriptor, syntax.GetLocation(), declarator.Symbol.Type));
return;
}
}
}
/// <summary>Creates a new ForStatementSyntax instance.</summary>
public static ForStatementSyntax ForStatement(VariableDeclarationSyntax declaration, SeparatedSyntaxList<ExpressionSyntax> initializers, ExpressionSyntax condition, SeparatedSyntaxList<ExpressionSyntax> incrementors, StatementSyntax statement)
{
return ForStatement(
SyntaxFactory.Token(SyntaxKind.ForKeyword),
SyntaxFactory.Token(SyntaxKind.OpenParenToken),
default(SyntaxToken),
null,
declaration,
initializers,
SyntaxFactory.Token(SyntaxKind.SemicolonToken),
condition,
SyntaxFactory.Token(SyntaxKind.SemicolonToken),
incrementors,
SyntaxFactory.Token(SyntaxKind.CloseParenToken),
statement);
}
private void MakeLocalVariableList(VariableDeclarationSyntax syntax)
{
int count = 0;
foreach (var v in syntax.Variables)
{
if (count == 0)
{
_output.Write(v.Identifier, v.Identifier.ValueText);
}
else
{
_output.TrivialWrite(", ");
_output.Write(v.Identifier, v.Identifier.ValueText);
}
if (v.Initializer != null)
{
_output.TrivialWrite(" = ");
this.Visit(v.Initializer);
}
count++;
}
}
public override void VisitVariableDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax node)
{
base.VisitVariableDeclaration(node);
TColor color;
if (node.Parent.IsKind(SyntaxKind.EventFieldDeclaration))
{
color = eventDeclarationColor;
}
else if (node.Parent.IsKind(SyntaxKind.FieldDeclaration))
{
color = fieldDeclarationColor;
}
else
{
color = variableDeclarationColor;
}
foreach (var declarations in node.Variables)
{
// var info = semanticModel.GetTypeInfo(declarations, cancellationToken);
Colorize(declarations.Identifier, color);
}
}
// doesn't include variables declared in declaration expressions
private static void GetLocalNames(VariableDeclarationSyntax localDeclaration, ref List<SyntaxToken> result)
{
foreach (var local in localDeclaration.Variables)
{
if (result == null)
{
result = new List<SyntaxToken>();
}
result.Add(local.Identifier);
}
}
private static bool TryComputeLocalsDistance(VariableDeclarationSyntax leftOpt, VariableDeclarationSyntax rightOpt, out double distance)
{
List<SyntaxToken> leftLocals = null;
List<SyntaxToken> rightLocals = null;
if (leftOpt != null)
{
GetLocalNames(leftOpt, ref leftLocals);
}
if (rightOpt != null)
{
GetLocalNames(rightOpt, ref rightLocals);
}
if (leftLocals == null || rightLocals == null)
{
distance = 0;
return false;
}
distance = ComputeDistance(leftLocals, rightLocals);
return true;
}
private static double ComputeWeightedDistance(
VariableDeclarationSyntax leftVariables,
StatementSyntax leftStatement,
VariableDeclarationSyntax rightVariables,
StatementSyntax rightStatement)
{
double distance = ComputeDistance(leftStatement, rightStatement);
// Put maximum weight behind the variables declared in the header of the statement.
double localsDistance;
if (TryComputeLocalsDistance(leftVariables, rightVariables, out localsDistance))
{
distance = distance * 0.4 + localsDistance * 0.6;
}
// If the statement is a block that declares local variables,
// weight them more than the rest of the statement.
return AdjustForLocalsInBlock(distance, leftStatement, rightStatement, localsWeight: 0.2);
}
/// <summary>
/// Given a variable declaration, figure out its type by looking at the declared symbol of the corresponding local.
/// </summary>
private SymbolInfo TypeFromLocal(VariableDeclarationSyntax variableDeclaration, CancellationToken cancellationToken)
{
TypeSymbol deconstructionType = (GetDeclaredSymbol(variableDeclaration.Variables.First(), cancellationToken) as LocalSymbol)?.Type;
if (deconstructionType?.IsErrorType() == false)
{
return new SymbolInfo(deconstructionType);
}
return SymbolInfo.None;
}
public LocalDeclarationStatementSyntax Update(
SyntaxTokenList modifiers,
VariableDeclarationSyntax declaration,
SyntaxToken semicolonToken
) => Update(AwaitKeyword, UsingKeyword, modifiers, declaration, semicolonToken);
internal SeparatedSyntaxList <VariableDeclaratorSyntax> RemodelVariableDeclaration(CSS.VariableDeclarationSyntax declaration)
{
var visualBasicSyntaxNode = declaration.Type.Accept(_nodesVisitor);
var type = (TypeSyntax)visualBasicSyntaxNode;
var declaratorsWithoutInitializers = new List <Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax>();
var declarators = new List <VariableDeclaratorSyntax>();
foreach (var v in declaration.Variables)
{
if (v.Initializer == null)
{
declaratorsWithoutInitializers.Add(v);
}
else
{
declarators.Add(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.SingletonSeparatedList(ExtractIdentifier(v)),
declaration.Type.IsVar ? null : SyntaxFactory.SimpleAsClause(type),
SyntaxFactory.EqualsValue((ExpressionSyntax)ConvertTopLevelExpression(v.Initializer.Value))
)
);
}
}
if (declaratorsWithoutInitializers.Count > 0)
{
declarators.Insert(0, SyntaxFactory.VariableDeclarator(SyntaxFactory.SeparatedList(declaratorsWithoutInitializers.Select(ExtractIdentifier)), SyntaxFactory.SimpleAsClause(type), null));
}
return(SyntaxFactory.SeparatedList(declarators));
}
internal BoundStatement BindForOrUsingOrFixedDeclarations(VariableDeclarationSyntax nodeOpt, LocalDeclarationKind localKind, DiagnosticBag diagnostics, out ImmutableArray<BoundLocalDeclaration> declarations)
{
if (nodeOpt == null)
{
declarations = ImmutableArray<BoundLocalDeclaration>.Empty;
return null;
}
var typeSyntax = nodeOpt.Type;
AliasSymbol alias;
bool isVar;
TypeSymbol declType = BindType(typeSyntax, diagnostics, out isVar, out alias);
Debug.Assert((object)declType != null || isVar);
var variables = nodeOpt.Variables;
int count = variables.Count;
Debug.Assert(count > 0);
if (isVar && count > 1)
{
// There are a number of ways in which a var decl can be illegal, but in these
// cases we should report an error and then keep right on going with the inference.
Error(diagnostics, ErrorCode.ERR_ImplicitlyTypedVariableMultipleDeclarator, nodeOpt);
}
var declarationArray = new BoundLocalDeclaration[count];
for (int i = 0; i < count; i++)
{
var variableDeclarator = variables[i];
var declaration = BindVariableDeclaration(localKind, isVar, variableDeclarator, typeSyntax, declType, alias, diagnostics);
declarationArray[i] = declaration;
}
declarations = declarationArray.AsImmutableOrNull();
return (count == 1) ?
(BoundStatement)declarations[0] :
new BoundMultipleLocalDeclarations(nodeOpt, declarations);
}
internal BoundLocalDeconstructionDeclaration BindDeconstructionDeclaration(CSharpSyntaxNode node, VariableDeclarationSyntax declaration, DiagnosticBag diagnostics)
{
Debug.Assert(node.Kind() == SyntaxKind.LocalDeclarationStatement || node.Kind() == SyntaxKind.VariableDeclaration);
Debug.Assert(declaration.IsDeconstructionDeclaration);
var value = declaration.Deconstruction.Value;
return new BoundLocalDeconstructionDeclaration(node, BindDeconstructionDeclaration(node, declaration, value, diagnostics));
}
internal BoundDeconstructionAssignmentOperator BindDeconstructionDeclaration(CSharpSyntaxNode node, VariableDeclarationSyntax declaration, ExpressionSyntax right, DiagnosticBag diagnostics, BoundDeconstructValuePlaceholder rightPlaceholder = null)
{
ArrayBuilder<DeconstructionVariable> locals = BindDeconstructionDeclarationLocals(declaration, declaration.Type, diagnostics);
var result = BindDeconstructionAssignment(node, right, locals, diagnostics, isDeclaration: true, rhsPlaceholder: rightPlaceholder);
FreeDeconstructionVariables(locals);
return result;
}
public UsingStatementSyntax Update(SyntaxToken usingKeyword, SyntaxToken openParenToken, VariableDeclarationSyntax declaration, ExpressionSyntax expression, SyntaxToken closeParenToken, StatementSyntax statement)
{
return(Update(awaitKeyword: default, usingKeyword, openParenToken, declaration, expression, closeParenToken, statement));
public override void VisitVariableDeclaration(VariableDeclarationSyntax node)
{
base.VisitVariableDeclaration(node);
}
public FixedStatementSyntax Update(SyntaxToken fixedKeyword, SyntaxToken openParenToken, VariableDeclarationSyntax declaration, SyntaxToken closeParenToken, StatementSyntax statement) => Update(attributeLists: default, fixedKeyword, openParenToken, declaration, closeParenToken, statement);
/// <summary>
/// build the summary text for the supplied member.
/// </summary>
/// <param name="variableDeclaratorSyntax">the variable declarator syntax.</param>
/// <param name="returnType">the return type for the member variable.</param>
/// <returns>a string containing the text.</returns>
public string BuildSummaryTextForMemberVariable(VariableDeclaratorSyntax variableDeclaratorSyntax, VariableDeclarationSyntax returnType)
{
if (variableDeclaratorSyntax == null)
throw new ArgumentNullException(nameof(variableDeclaratorSyntax));
if (returnType == null)
throw new ArgumentNullException(nameof(returnType));
var id = returnType.Type.GetIdentifierName();
var word = variableDeclaratorSyntax.Identifier.Text.Length > (id ?? string.Empty).Length
? variableDeclaratorSyntax.Identifier.Text
: id;
var words = this.SplitCamelCaseWords(word);
var text = $"the {string.Join(" ", this.RemoveInvalidPrefix(this.RemoveNonPrintables(words)))}.";
return text;
}
private void ClassifyUpdate(VariableDeclarationSyntax oldNode, VariableDeclarationSyntax newNode)
{
if (!SyntaxFactory.AreEquivalent(oldNode.Type, newNode.Type))
{
ReportError(RudeEditKind.TypeUpdate);
return;
}
// separators may be added/removed:
}
/// <summary>
/// Prepares locals corresponding to the variables of the declaration.
/// The locals are kept in a tree which captures the nesting of variables.
/// Each local is either a simple local (when its type is known) or a deconstruction local pending inference.
/// The caller is responsible for releasing the nested ArrayBuilders.
/// </summary>
private ArrayBuilder<DeconstructionVariable> BindDeconstructionDeclarationLocals(VariableDeclarationSyntax node, TypeSyntax closestTypeSyntax, DiagnosticBag diagnostics)
{
Debug.Assert(node.IsDeconstructionDeclaration);
SeparatedSyntaxList<VariableDeclarationSyntax> variables = node.Deconstruction.Variables;
// There are four cases for VariableDeclaration:
// - type and declarators are set, but deconstruction is null. This could represent `int x`, which is a single variable.
// - type is null, declarators are set, but deconstruction is null. This could represent `x`, which is a single variable.
// - type is set to 'var', declarators are null, and deconstruction is set. This could represent `var (...)`
// - type and declarators are null, but deconstruction is set. This could represent `(int x, ...)`
var localsBuilder = ArrayBuilder<DeconstructionVariable>.GetInstance(variables.Count);
foreach (var variable in variables)
{
TypeSyntax typeSyntax = variable.Type ?? closestTypeSyntax;
DeconstructionVariable local;
if (variable.IsDeconstructionDeclaration)
{
local = new DeconstructionVariable(BindDeconstructionDeclarationLocals(variable, typeSyntax, diagnostics), node.Deconstruction);
}
else
{
local = new DeconstructionVariable(BindDeconstructionDeclarationLocal(variable, typeSyntax, diagnostics));
}
localsBuilder.Add(local);
}
return localsBuilder;
}
private bool ShouldAnalyzeVariableDeclaration(VariableDeclarationSyntax variableDeclaration, SemanticModel semanticModel, CancellationToken cancellationToken)
{
// implict type is applicable only for local variables and
// such declarations cannot have multiple declarators and
// must have an initializer.
var isSupportedParentKind = variableDeclaration.IsParentKind(
SyntaxKind.LocalDeclarationStatement,
SyntaxKind.ForStatement,
SyntaxKind.UsingStatement);
return isSupportedParentKind &&
variableDeclaration.Variables.Count == 1 &&
variableDeclaration.Variables.Single().Initializer.IsKind(SyntaxKind.EqualsValueClause);
}
public LocalDeclarationStatementSyntax Update(SyntaxTokenList modifiers, VariableDeclarationSyntax declaration, SyntaxToken semicolonToken) => Update(default(SyntaxToken), default(SyntaxToken), modifiers, declaration, semicolonToken);
/// <summary>
/// Returns a BoundLocal when the type was explicit, otherwise returns a DeconstructionLocalPendingInference.
/// </summary>
private BoundExpression BindDeconstructionDeclarationLocal(VariableDeclarationSyntax node, TypeSyntax closestTypeSyntax, DiagnosticBag diagnostics)
{
Debug.Assert(!node.IsDeconstructionDeclaration);
Debug.Assert(node.Variables.Count == 1);
var declarator = node.Variables[0];
var localSymbol = LocateDeclaredVariableSymbol(declarator, closestTypeSyntax);
// Check for variable declaration errors.
// Use the binder that owns the scope for the local because this (the current) binder
// might own nested scope.
bool hasErrors = localSymbol.Binder.ValidateDeclarationNameConflictsInScope(localSymbol, diagnostics);
bool isVar;
bool isConst = false;
AliasSymbol alias;
TypeSymbol declType = BindVariableType(node, diagnostics, closestTypeSyntax, ref isConst, out isVar, out alias);
if (!isVar)
{
if (node.Type == null)
{
// An explicit type can only be provided next to the variable
Error(diagnostics, ErrorCode.ERR_DeconstructionVarFormDisallowsSpecificType, node);
}
return new BoundLocal(declarator, localSymbol, constantValueOpt: null, type: declType, hasErrors: node.Type == null);
}
return new DeconstructionLocalPendingInference(declarator, localSymbol);
}
private void ClassifyFieldInsert(VariableDeclarationSyntax fieldVariable)
{
ClassifyFieldInsert((BaseFieldDeclarationSyntax)fieldVariable.Parent);
}
public ForStatementSyntax Update(SyntaxToken forKeyword, SyntaxToken openParenToken, VariableDeclarationSyntax declaration, SeparatedSyntaxList <ExpressionSyntax> initializers, SyntaxToken firstSemicolonToken, ExpressionSyntax condition, SyntaxToken secondSemicolonToken, SeparatedSyntaxList <ExpressionSyntax> incrementors, SyntaxToken closeParenToken, StatementSyntax statement) => Update(AttributeLists, forKeyword, openParenToken, declaration, initializers, firstSemicolonToken, condition, secondSemicolonToken, incrementors, closeParenToken, statement);
private async Task<bool> SemanticsChangedAsync(
Document document,
VariableDeclarationSyntax declaration,
ExpressionSyntax invocationOrCreation,
TypeSyntax newType,
IdentifierNameSyntax identifier,
DeclarationExpressionSyntax declarationExpression,
CancellationToken cancellationToken)
{
if (newType.IsVar)
{
// Options want us to use 'var' if we can. Make sure we didn't change
// the semantics of teh call by doing this.
// Find the symbol that the existing invocation points to.
var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
var previousSymbol = semanticModel.GetSymbolInfo(invocationOrCreation).Symbol;
var annotation = new SyntaxAnnotation();
var updatedInvocationOrCreation = invocationOrCreation.ReplaceNode(
identifier, declarationExpression).WithAdditionalAnnotations(annotation);
// Note(cyrusn): "https://github.com/dotnet/roslyn/issues/14384" prevents us from just
// speculatively binding the new expression. So, instead, we fork things and see if
// the new symbol we bind to is equivalent to the previous one.
var newDocument = document.WithSyntaxRoot(
root.ReplaceNode(invocationOrCreation, updatedInvocationOrCreation));
var newRoot = await newDocument.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var newSemanticModel = await newDocument.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
updatedInvocationOrCreation = (ExpressionSyntax)newRoot.GetAnnotatedNodes(annotation).Single();
var updatedSymbol = newSemanticModel.GetSymbolInfo(updatedInvocationOrCreation).Symbol;
if (!SymbolEquivalenceComparer.Instance.Equals(previousSymbol, updatedSymbol))
{
// We're pointing at a new symbol now. Semantic have changed.
return true;
}
}
return false;
}
static SeparatedSyntaxList <VariableDeclaratorSyntax> RemodelVariableDeclaration(CSS.VariableDeclarationSyntax declaration, NodesVisitor nodesVisitor)
{
var type = (TypeSyntax)declaration.Type.Accept(nodesVisitor);
var declaratorsWithoutInitializers = new List <CSS.VariableDeclaratorSyntax>();
var declarators = new List <VariableDeclaratorSyntax>();
foreach (var v in declaration.Variables)
{
if (v.Initializer == null)
{
declaratorsWithoutInitializers.Add(v);
continue;
}
else
{
declarators.Add(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.SingletonSeparatedList(ExtractIdentifier(v)),
declaration.Type.IsVar ? null : SyntaxFactory.SimpleAsClause(type),
SyntaxFactory.EqualsValue((ExpressionSyntax)v.Initializer.Value.Accept(nodesVisitor))
)
);
}
}
if (declaratorsWithoutInitializers.Count > 0)
{
declarators.Insert(0, SyntaxFactory.VariableDeclarator(SyntaxFactory.SeparatedList(declaratorsWithoutInitializers.Select(ExtractIdentifier)), SyntaxFactory.SimpleAsClause(type), null));
}
return(SyntaxFactory.SeparatedList(declarators));
}