private StatementSyntax ParseDeclarationStatement()
{
var typedefKeyword = NextTokenIf(SyntaxKind.TypedefKeyword);
var mods = new List<SyntaxToken>();
var variables = new List<SyntaxNode>();
ParseDeclarationModifiers(mods);
var type = ParseType(false);
if (typedefKeyword != null)
{
ParseTypeAliases(variables);
var semi = Match(SyntaxKind.SemiToken);
return new TypedefStatementSyntax(typedefKeyword, mods, type, new SeparatedSyntaxList<TypeAliasSyntax>(variables), semi);
}
if (type is TypeDefinitionSyntax && (Current.Kind == SyntaxKind.SemiToken || Current.Kind == SyntaxKind.EndOfFileToken))
{
var semi = Match(SyntaxKind.SemiToken);
return new TypeDeclarationStatementSyntax(mods, (TypeDefinitionSyntax) type, semi);
}
else
{
ParseVariableDeclarators(type, variables, variableDeclarationsExpected: true);
var semi = Match(SyntaxKind.SemiToken);
var variableDeclaration = new VariableDeclarationSyntax(mods, type, new SeparatedSyntaxList<VariableDeclaratorSyntax>(variables));
return new VariableDeclarationStatementSyntax(variableDeclaration, semi);
}
}
public static IEnumerable<ReplaceAction> GetSimplifications(VariableDeclarationSyntax declaration, ISemanticModel model, Assumptions assume, CancellationToken cancellationToken = default(CancellationToken))
{
if (declaration.Variables.Count != 1) yield break;
var v = declaration.Variables.Single();
if (v.Initializer == null) yield break;
if (declaration.Type.IsVar) yield break;
var declaredType = model.GetTypeInfo(declaration.Type);
var valueType = model.GetTypeInfo(v.Initializer.Value);
if (!declaredType.Equals(valueType)) yield break;
yield return new ReplaceAction("Use 'var'", declaration.Type, Syntax.IdentifierName("var"));
}
public static ForStatementSyntax ConvertWhileStatementToForStatement(
WhileStatementSyntax whileStatement,
VariableDeclarationSyntax declaration = default,
SeparatedSyntaxList <ExpressionSyntax> initializers = default)
{
var incrementors = default(SeparatedSyntaxList <ExpressionSyntax>);
StatementSyntax statement = whileStatement.Statement;
if (statement is BlockSyntax block)
{
SyntaxList <StatementSyntax> statements = block.Statements;
if (statements.Any())
{
int startIndex = -1;
int i = statements.Count - 1;
bool fContinue = statements.Last().IsKind(SyntaxKind.ContinueStatement);
if (fContinue)
{
i--;
}
while (i >= 0)
{
if (!(statements[i] is ExpressionStatementSyntax expressionStatement))
{
break;
}
ExpressionSyntax expression = expressionStatement.Expression;
if (expression == null ||
!CSharpFacts.IsIncrementOrDecrementExpression(expression.Kind()))
{
break;
}
startIndex = i;
i--;
}
if (startIndex >= 0)
{
int count = statements.Count - startIndex;
if (fContinue)
{
count--;
}
incrementors = statements
.Skip(startIndex)
.Take(count)
.Cast <ExpressionStatementSyntax>()
.Select(f => f.Expression)
.ToSeparatedSyntaxList();
statement = block.WithStatements(statements.RemoveRange(startIndex, statements.Count - startIndex));
}
else if (fContinue)
{
statement = block.WithStatements(statements.RemoveAt(statements.Count - 1));
}
}
}
ExpressionSyntax condition = whileStatement.Condition;
if (condition.IsKind(SyntaxKind.TrueLiteralExpression))
{
condition = null;
}
return(ForStatement(
forKeyword: Token(SyntaxKind.ForKeyword).WithTriviaFrom(whileStatement.WhileKeyword),
openParenToken: Token(whileStatement.OpenParenToken.LeadingTrivia, SyntaxKind.OpenParenToken, default),
declaration: declaration,
initializers: initializers,
firstSemicolonToken: SemicolonToken(),
condition: condition,
secondSemicolonToken: SemicolonToken(),
incrementors: incrementors,
closeParenToken: Token(default, SyntaxKind.CloseParenToken, whileStatement.CloseParenToken.TrailingTrivia),
public override void VisitVariableDeclarationSyntax(VariableDeclarationSyntax syntax)
{
AddCodeFixIfSingleInterpolatedString(syntax.Value);
base.VisitVariableDeclarationSyntax(syntax);
}
public static LocalDeclarationStatementSyntax LocalDeclarationStatement(
SyntaxTokenList modifiers,
VariableDeclarationSyntax declaration,
SyntaxToken semicolonToken
) =>
public static TypeAnalysisFlags AnalyzeType(
VariableDeclarationSyntax variableDeclaration,
SemanticModel semanticModel,
CancellationToken cancellationToken = default(CancellationToken))
{
if (variableDeclaration == null)
{
throw new ArgumentNullException(nameof(variableDeclaration));
}
if (semanticModel == null)
{
throw new ArgumentNullException(nameof(semanticModel));
}
TypeSyntax type = variableDeclaration.Type;
if (type != null)
{
SeparatedSyntaxList <VariableDeclaratorSyntax> variables = variableDeclaration.Variables;
if (variables.Count > 0 &&
!variableDeclaration.IsParentKind(SyntaxKind.FieldDeclaration, SyntaxKind.EventFieldDeclaration))
{
ExpressionSyntax expression = variables[0].Initializer?.Value;
if (expression != null)
{
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(type, cancellationToken);
if (typeSymbol?.IsErrorType() == false)
{
TypeAnalysisFlags flags;
if (typeSymbol.IsDynamicType())
{
flags = TypeAnalysisFlags.Dynamic;
}
else
{
flags = TypeAnalysisFlags.ValidSymbol;
if (type.IsVar)
{
flags |= TypeAnalysisFlags.Implicit;
if (typeSymbol.SupportsExplicitDeclaration())
{
flags |= TypeAnalysisFlags.SupportsExplicit;
}
}
else
{
flags |= TypeAnalysisFlags.Explicit;
if (variables.Count == 1 &&
!IsLocalConstDeclaration(variableDeclaration) &&
!expression.IsKind(SyntaxKind.NullLiteralExpression) &&
typeSymbol.Equals(semanticModel.GetTypeSymbol(expression, cancellationToken)))
{
flags |= TypeAnalysisFlags.SupportsImplicit;
}
}
if (IsTypeObvious(expression, semanticModel, cancellationToken))
{
flags |= TypeAnalysisFlags.TypeObvious;
}
}
return(flags);
}
}
}
}
return(TypeAnalysisFlags.None);
}
public override void VisitVariableDeclaration(VariableDeclarationSyntax node)
{
Visit(node.Initializer?.Value);
}
public void Add(SyntaxTokenList modifiers, VariableDeclarationSyntax decl)
{
TypeExtraInfo tei = Chunk.AddTypeExtraInfo(this.Class);
foreach (VariableDeclaratorSyntax vds in decl.Variables)
{
TypeInfo ti = Chunk.Model.GetTypeInfo(decl.Type);
tei.AddField(modifiers, ti.ConvertedType, vds);
}
}
internal SeparatedSyntaxList <VariableDeclaratorSyntax> RemodelVariableDeclaration(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));
}
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);
}
public static SingleLocalDeclarationStatementInfo SingleLocalDeclarationStatementInfo(
VariableDeclarationSyntax variableDeclaration,
bool allowMissing = false)
{
return(Syntax.SingleLocalDeclarationStatementInfo.Create(variableDeclaration, allowMissing));
}
public static TypeAnalysisResult AnalyzeType(
VariableDeclarationSyntax variableDeclaration,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
if (variableDeclaration.Type == null)
{
return(TypeAnalysisResult.None);
}
if (variableDeclaration.Variables.Count == 0)
{
return(TypeAnalysisResult.None);
}
if (variableDeclaration.Parent?.IsKind(SyntaxKind.FieldDeclaration) == true)
{
return(TypeAnalysisResult.None);
}
ExpressionSyntax expression = variableDeclaration.Variables[0].Initializer?.Value;
if (expression == null)
{
return(TypeAnalysisResult.None);
}
ITypeSymbol typeSymbol = semanticModel.GetTypeInfo(variableDeclaration.Type, cancellationToken).Type;
if (typeSymbol == null || typeSymbol.IsKind(SymbolKind.ErrorType))
{
return(TypeAnalysisResult.None);
}
if (typeSymbol.IsAnonymousType)
{
return(TypeAnalysisResult.None);
}
if (typeSymbol.IsKind(SymbolKind.NamedType))
{
if (((INamedTypeSymbol)typeSymbol).IsAnyTypeArgumentAnonymousType())
{
return(TypeAnalysisResult.None);
}
}
else if (!typeSymbol.IsKind(SymbolKind.ArrayType))
{
return(TypeAnalysisResult.None);
}
if (variableDeclaration.Variables.Count > 1)
{
if (variableDeclaration.Type.IsVar)
{
return(TypeAnalysisResult.ImplicitButShouldBeExplicit);
}
else
{
return(TypeAnalysisResult.None);
}
}
if (IsImplicitTypeAllowed(typeSymbol, expression, semanticModel, cancellationToken))
{
if (variableDeclaration.Type.IsVar)
{
return(TypeAnalysisResult.Implicit);
}
else
{
return(TypeAnalysisResult.ExplicitButShouldBeImplicit);
}
}
else
{
if (variableDeclaration.Type.IsVar)
{
return(TypeAnalysisResult.ImplicitButShouldBeExplicit);
}
else
{
return(TypeAnalysisResult.Explicit);
}
}
}
// // Summary: // Called when the visitor visits a VariableDeclarationSyntax node. public virtual void VisitVariableDeclaration(VariableDeclarationSyntax node);
public static void AnalyzeUsingStatement(SyntaxNodeAnalysisContext context)
{
var usingStatement = (UsingStatementSyntax)context.Node;
StatementSyntax statement = usingStatement.Statement;
if (statement?.IsKind(SyntaxKind.Block) == true)
{
var block = (BlockSyntax)statement;
StatementSyntax lastStatement = block.Statements.LastOrDefault();
if (lastStatement?.IsKind(SyntaxKind.ExpressionStatement) == true)
{
var expressionStatement = (ExpressionStatementSyntax)lastStatement;
ExpressionSyntax expression = expressionStatement.Expression;
if (expression?.IsKind(SyntaxKind.InvocationExpression) == true)
{
var invocation = (InvocationExpressionSyntax)expression;
ExpressionSyntax invocationExpression = invocation.Expression;
if (invocationExpression?.IsKind(SyntaxKind.SimpleMemberAccessExpression) == true)
{
var memberAccess = (MemberAccessExpressionSyntax)invocationExpression;
if (invocation.ArgumentList?.Arguments.Count == 0)
{
string methodName = memberAccess.Name?.Identifier.ValueText;
if (methodName == "Dispose" || methodName == "Close")
{
ExpressionSyntax memberAccessExpression = memberAccess.Expression;
if (memberAccessExpression != null)
{
ExpressionSyntax usingExpression = usingStatement.Expression;
if (usingExpression != null)
{
if (SyntaxComparer.AreEquivalent(memberAccessExpression, usingExpression))
{
ReportDiagnostic(context, expressionStatement, methodName);
}
}
else if (memberAccessExpression.IsKind(SyntaxKind.IdentifierName))
{
VariableDeclarationSyntax usingDeclaration = usingStatement.Declaration;
if (usingDeclaration != null)
{
var identifierName = (IdentifierNameSyntax)memberAccessExpression;
string name = identifierName.Identifier.ValueText;
VariableDeclaratorSyntax declarator = usingDeclaration.Variables.LastOrDefault();
if (declarator != null &&
declarator.Identifier.ValueText == name)
{
ISymbol symbol = context.SemanticModel.GetDeclaredSymbol(declarator, context.CancellationToken);
if (symbol?.Equals(context.SemanticModel.GetSymbol(identifierName, context.CancellationToken)) == true)
{
ReportDiagnostic(context, expressionStatement, methodName);
}
}
}
}
}
}
}
}
}
}
}
}
public override void VisitVariableDeclarationSyntax(VariableDeclarationSyntax syntax)
{
this.activeLoopCapableTopLevelDeclaration = syntax;
base.VisitVariableDeclarationSyntax(syntax);
this.activeLoopCapableTopLevelDeclaration = null;
}
public BoundMultipleVariableDeclarations(VariableDeclarationSyntax syntax, ImmutableArray<BoundVariableDeclaration> variableDeclarations)
: base(BoundNodeKind.MultipleVariableDeclarations, syntax)
{
VariableDeclarations = variableDeclarations;
}
public void VisitVariableDeclaration(VariableDeclarationSyntax node)
{
if (node == null)
throw new ArgumentNullException("node");
node.Validate();
node.Type.Accept(this);
_writer.WriteSpace();
if (_writer.Configuration.Other.AlignMultiLineConstructs.MultipleDeclarations)
_writer.SetAlignmentBreak(true);
_writer.PushWrapStyle(_writer.Configuration.LineBreaksAndWrapping.LineWrapping.WrapMultipleDeclarations);
bool hadOne = false;
foreach (var variable in node.Variables)
{
if (hadOne)
_writer.WriteListSeparator();
else
hadOne = true;
variable.Accept(this);
}
_writer.PopWrapStyle();
if (_writer.Configuration.Other.AlignMultiLineConstructs.MultipleDeclarations)
_writer.SetAlignmentBreak(false);
}
public override void VisitVariableDeclaration(VariableDeclarationSyntax node)
{
base.VisitVariableDeclaration(node);
foreach (var identifier in node.Variables.Select(a => a.Identifier.ValueText))
{
identifiers[identifier] = 1 + (identifiers.ContainsKey(identifier) ? identifiers[identifier] : 0);
}
}
public override void VisitVariableDeclaration(VariableDeclarationSyntax node)
{
base.VisitVariableDeclaration(node);
}
public override void VisitVariableDeclarationSyntax(VariableDeclarationSyntax syntax)
=> AssignTypeWithCaching(syntax, () => {
return(VisitAndReturnType(syntax.Value));
});
private BoundMultipleVariableDeclarations BindVariableDeclaration(VariableDeclarationSyntax syntax, Symbol parent)
{
return BindVariableDeclaration(syntax, parent, (d, t) => new VariableSymbol(d, parent, t));
}
public static void ComputeRefactoring(
RefactoringContext context,
LocalDeclarationStatementSyntax localDeclaration,
SemanticModel semanticModel)
{
if (semanticModel.GetEnclosingSymbol(localDeclaration.SpanStart, context.CancellationToken) is not IMethodSymbol methodSymbol)
return;
if (methodSymbol.IsImplicitlyDeclared)
return;
if (!methodSymbol.MethodKind.Is(MethodKind.Ordinary, MethodKind.LocalFunction))
return;
if (methodSymbol.PartialImplementationPart != null)
methodSymbol = methodSymbol.PartialImplementationPart;
SyntaxNode methodOrLocalFunction = methodSymbol.GetSyntax(context.CancellationToken);
if (!methodOrLocalFunction.IsKind(SyntaxKind.MethodDeclaration, SyntaxKind.LocalFunctionStatement))
return;
VariableDeclarationSyntax declaration = localDeclaration.Declaration;
if (declaration == null)
return;
VariableDeclaratorSyntax variable = declaration
.Variables
.FirstOrDefault(f => !f.IsMissing && f.Identifier.Span.Contains(context.Span));
if (variable == null)
return;
TypeSyntax type = declaration.Type;
if (type == null)
return;
if (type.IsVar)
{
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(type, context.CancellationToken);
if (typeSymbol?.SupportsExplicitDeclaration() == true)
{
type = typeSymbol.ToTypeSyntax();
}
else
{
return;
}
}
context.RegisterRefactoring(
$"Promote '{variable.Identifier.ValueText}' to parameter",
ct =>
{
return RefactorAsync(
context.Document,
methodOrLocalFunction,
localDeclaration,
type.WithoutTrivia().WithSimplifierAnnotation(),
variable,
ct);
},
RefactoringDescriptors.PromoteLocalVariableToParameter);
}
private static void AnalyzeUsingStatement(SyntaxNodeAnalysisContext context)
{
var usingStatement = (UsingStatementSyntax)context.Node;
StatementSyntax statement = usingStatement.Statement;
if (statement?.Kind() != SyntaxKind.Block)
{
return;
}
var block = (BlockSyntax)statement;
StatementSyntax lastStatement = block.Statements.LastOrDefault();
if (lastStatement == null)
{
return;
}
if (lastStatement.SpanContainsDirectives())
{
return;
}
SimpleMemberInvocationStatementInfo info = SyntaxInfo.SimpleMemberInvocationStatementInfo(lastStatement);
if (!info.Success)
{
return;
}
if (info.Arguments.Any())
{
return;
}
string methodName = info.NameText;
if (methodName != "Dispose" && methodName != "Close")
{
return;
}
ExpressionSyntax usingExpression = usingStatement.Expression;
if (usingExpression != null)
{
if (CSharpFactory.AreEquivalent(info.Expression, usingExpression))
{
ReportDiagnostic(context, info.Statement, methodName);
}
}
else
{
VariableDeclarationSyntax usingDeclaration = usingStatement.Declaration;
if (usingDeclaration != null &&
info.Expression.Kind() == SyntaxKind.IdentifierName)
{
var identifierName = (IdentifierNameSyntax)info.Expression;
VariableDeclaratorSyntax declarator = usingDeclaration.Variables.LastOrDefault();
if (declarator != null &&
declarator.Identifier.ValueText == identifierName.Identifier.ValueText)
{
ISymbol symbol = context.SemanticModel.GetDeclaredSymbol(declarator, context.CancellationToken);
if (SymbolEqualityComparer.Default.Equals(symbol, context.SemanticModel.GetSymbol(identifierName, context.CancellationToken)))
{
ReportDiagnostic(context, info.Statement, methodName);
}
}
}
}
}
internal static async Task ComputeRefactoringAsync(RefactoringContext context, VariableDeclarationSyntax variableDeclaration)
{
SyntaxNode parent = variableDeclaration.Parent;
if (parent?.IsKind(SyntaxKind.LocalDeclarationStatement) == true)
{
TypeSyntax type = variableDeclaration.Type;
if (type != null)
{
VariableDeclaratorSyntax variableDeclarator = variableDeclaration.Variables.SingleOrDefault(throwException: false);
ExpressionSyntax value = variableDeclarator?.Initializer?.Value;
if (value?.IsKind(SyntaxKind.NullLiteralExpression) == false &&
CanBeEqualToNull(value))
{
SyntaxToken identifier = variableDeclarator.Identifier;
if (context.Span.IsContainedInSpanOrBetweenSpans(identifier))
{
IdentifierNameSyntax identifierName = IdentifierName(identifier);
var localDeclaration = (StatementSyntax)parent;
if (!NullCheckExists(identifierName, localDeclaration))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
if (semanticModel
.GetTypeSymbol(type, context.CancellationToken)?
.IsReferenceType == true)
{
RegisterRefactoring(context, identifierName, localDeclaration);
}
}
}
}
}
}
}
public static FixedStatementSyntax FixedStatement(SyntaxToken fixedKeyword, SyntaxToken openParenToken, VariableDeclarationSyntax declaration, SyntaxToken closeParenToken, StatementSyntax statement) => FixedStatement(attributeLists: default, fixedKeyword, openParenToken, declaration, closeParenToken, statement);
public static ForStatementSyntax ForStatement(VariableDeclarationSyntax declaration, SeparatedSyntaxList <ExpressionSyntax> initializers, ExpressionSyntax condition, SeparatedSyntaxList <ExpressionSyntax> incrementors, StatementSyntax statement) => ForStatement(attributeLists: default, declaration, initializers, condition, incrementors, statement);
private bool ParseVariableDeclarationStatementSyntax(VariableDeclarationStatementSyntax syntax, List <string> registers)
{
VariableDeclarationSyntax varDeclaration = syntax.Declaration;
TypeSyntax type = varDeclaration.Type;
foreach (VariableDeclaratorSyntax var in varDeclaration.Variables)
{
AnnotationFactory.BeginVar();
AnnotationFactory.SetModifiers(varDeclaration.Modifiers);
if (AnnotationFactory.IsGroupOpen())
{
AnnotationFactory.SetType(type);
AnnotationFactory.SetAnnotations(var.Annotations?.Annotations ?? null);
InitializerSyntax initializer = var.Initializer;
if (varDeclaration.Variables[0].ArrayRankSpecifiers.Count > 0)
{
LiteralExpressionSyntax litExpressionSyntax = varDeclaration.Variables[0].ArrayRankSpecifiers[0].Dimension as LiteralExpressionSyntax;
AnnotationFactory.SetDimension((int)litExpressionSyntax.Token.Value);
}
if (initializer != null && initializer is EqualsValueClauseSyntax)
{
EqualsValueClauseSyntax evcSyntax = (EqualsValueClauseSyntax)initializer;
if (evcSyntax.Value is NumericConstructorInvocationExpressionSyntax)
{
NumericConstructorInvocationExpressionSyntax ncieSyntax = (NumericConstructorInvocationExpressionSyntax)evcSyntax.Value;
SeparatedSyntaxList <ExpressionSyntax> arguments = ncieSyntax.ArgumentList.Arguments;
}
else if (evcSyntax.Value is LiteralExpressionSyntax)
{
}
}
SyntaxToken name = var.Identifier;
AnnotationFactory.SetName(name.ValueText);
foreach (var qualifier in var.Qualifiers)
{
if (qualifier is RegisterLocation)
{
string register = ((RegisterLocation)qualifier).Register.ValueText;
if (registers.Contains(register))
{
MessageBox.Show($"Register: {register}\nDefined multiple times, ShaderBox can not decides which one needs to be binded.\n\nWill be resolved in a future release.", "Unsupported operation", MessageBoxButton.OK, MessageBoxImage.Error);
AnnotationFactory.DestroyGroup();
return(false);
}
AnnotationFactory.SetRegister(register);
}
}
if (string.IsNullOrWhiteSpace(AnnotationFactory.GetRegister()))
{
AnnotationFactory.DestroyGroup();
}
else
{
AnnotationFactory.EndVar();
}
}
}
return(true);
}
public override void VisitVariableDeclarationSyntax(VariableDeclarationSyntax syntax)
{
allowedFlags = FunctionFlags.RequiresInlining;
base.VisitVariableDeclarationSyntax(syntax);
allowedFlags = FunctionFlags.Default;
}
private static IEnumerable <SyntaxToken> GetIdentifiers(VariableDeclarationSyntax declaration)
{
return(declaration.Variables
.Select(v => v.Identifier)
.ToImmutableArray());
}
public static Task <Document> RefactorAsync(
Document document,
ForEachStatementSyntax forEachStatement,
SemanticModel semanticModel,
bool reverseLoop = false,
CancellationToken cancellationToken = default(CancellationToken))
{
string name = NameGenerator.Default.EnsureUniqueLocalName(
DefaultNames.ForVariable,
semanticModel,
forEachStatement.Statement.SpanStart,
cancellationToken: cancellationToken);
SyntaxToken identifier = Identifier(name);
if (name != DefaultNames.ForVariable)
{
identifier = identifier.WithRenameAnnotation();
}
ExpressionSyntax forEachExpression = forEachStatement.Expression;
MemberAccessExpressionSyntax countOrLengthMemberAccess = SimpleMemberAccessExpression(
forEachExpression.WithoutTrivia(),
IdentifierName(CSharpUtility.GetCountOrLengthPropertyName(forEachExpression, semanticModel, cancellationToken)));
VariableDeclarationSyntax declaration = null;
BinaryExpressionSyntax condition = null;
PostfixUnaryExpressionSyntax incrementor = null;
if (reverseLoop)
{
declaration = VariableDeclaration(
IntType(),
identifier,
EqualsValueClause(
SubtractExpression(
countOrLengthMemberAccess,
NumericLiteralExpression(1))));
condition = GreaterThanOrEqualExpression(IdentifierName(name), NumericLiteralExpression(0));
incrementor = PostDecrementExpression(IdentifierName(name));
}
else
{
declaration = VariableDeclaration(
IntType(),
identifier,
EqualsValueClause(NumericLiteralExpression(0)));
condition = LessThanExpression(
IdentifierName(name),
countOrLengthMemberAccess);
incrementor = PostIncrementExpression(IdentifierName(name));
}
StatementSyntax statement = forEachStatement.Statement.ReplaceNodes(
GetVariableReferences(forEachStatement, semanticModel, cancellationToken),
(node, rewrittenNode) =>
{
return(ElementAccessExpression(
forEachExpression.WithoutTrivia(),
BracketedArgumentList(SingletonSeparatedList(Argument(IdentifierName(name))))
).WithTriviaFrom(node));
});
ForStatementSyntax forStatement = ForStatement(
declaration: declaration,
initializers: default(SeparatedSyntaxList <ExpressionSyntax>),
condition: condition,
incrementors: SingletonSeparatedList <ExpressionSyntax>(incrementor),
statement: statement);
forStatement = forStatement
.WithTriviaFrom(forEachStatement)
.WithFormatterAnnotation();
return(document.ReplaceNodeAsync(forEachStatement, forStatement, cancellationToken));
}
private async Task <Document> MakeConstAsync(Document document, LocalDeclarationStatementSyntax localDeclaration, CancellationToken cancellationToken)
{
// Remove the leading trivia from the local declaration.
SyntaxToken firstToken = localDeclaration.GetFirstToken();
SyntaxTriviaList leadingTrivia = firstToken.LeadingTrivia;
LocalDeclarationStatementSyntax trimmedLocal = localDeclaration.ReplaceToken(
firstToken, firstToken.WithLeadingTrivia(SyntaxTriviaList.Empty));
// Create a const token with the leading trivia.
SyntaxToken constToken = SyntaxFactory.Token(leadingTrivia, SyntaxKind.ConstKeyword, SyntaxFactory.TriviaList(SyntaxFactory.ElasticMarker));
// Insert the const token into the modifiers list, creating a new modifiers list.
SyntaxTokenList newModifiers = trimmedLocal.Modifiers.Insert(0, constToken);
// If the type of declaration is 'var', create a new type name for the
// type inferred for 'var'.
VariableDeclarationSyntax variableDeclaration = localDeclaration.Declaration;
TypeSyntax variableTypeName = variableDeclaration.Type;
if (variableTypeName.IsVar)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken);
// 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 != "var")
{
// Create a new TypeSyntax for the inferred type. Be careful
// to keep any leading and trailing trivia from the var keyword.
TypeSyntax typeName = SyntaxFactory.ParseTypeName(type.ToDisplayString())
.WithLeadingTrivia(variableTypeName.GetLeadingTrivia())
.WithTrailingTrivia(variableTypeName.GetTrailingTrivia());
// Add an annotation to simplify the type name.
TypeSyntax simplifiedTypeName = typeName.WithAdditionalAnnotations(Simplifier.Annotation);
// Replace the type in the variable declaration.
variableDeclaration = variableDeclaration.WithType(simplifiedTypeName);
}
}
}
// Produce the new local declaration.
LocalDeclarationStatementSyntax newLocal = trimmedLocal.WithModifiers(newModifiers)
.WithDeclaration(variableDeclaration);
// Add an annotation to format the new local declaration.
LocalDeclarationStatementSyntax formattedLocal = newLocal.WithAdditionalAnnotations(Formatter.Annotation);
// Replace the old local declaration with the new local declaration.
SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken);
SyntaxNode newRoot = root.ReplaceNode(localDeclaration, formattedLocal);
// Return document with transformed tree.
return(document.WithSyntaxRoot(newRoot));
}
public LocalDeclarationStatementSyntax Update(SyntaxTokenList modifiers, VariableDeclarationSyntax declaration, SyntaxToken semicolonToken) => Update(default(SyntaxToken), default(SyntaxToken), declaration, semicolonToken);
public void Flatten(VariableDeclarationSyntax node, List<FlatStatement> instructions)
{
/*
public TypeSyntax Type { get; }
public SeparatedSyntaxList<VariableDeclaratorSyntax> Variables { get; }
/**/
TypeInfo ti = Model.GetTypeInfo(node.Type);
foreach (VariableDeclaratorSyntax vds in node.Variables)
{
Flatten(ti.Type, vds, instructions);
}
}
internal static BoundStatement BindUsingStatementOrDeclarationFromParts(SyntaxNode syntax, SyntaxToken usingKeyword, SyntaxToken awaitKeyword, Binder originalBinder, UsingStatementBinder usingBinderOpt, DiagnosticBag diagnostics)
{
bool isUsingDeclaration = syntax.Kind() == SyntaxKind.LocalDeclarationStatement;
bool isExpression = !isUsingDeclaration && syntax.Kind() != SyntaxKind.VariableDeclaration;
bool hasAwait = awaitKeyword != default;
Debug.Assert(isUsingDeclaration || usingBinderOpt != null);
TypeSymbol disposableInterface = getDisposableInterface(hasAwait);
Debug.Assert((object)disposableInterface != null);
bool hasErrors = ReportUseSiteDiagnostics(disposableInterface, diagnostics, hasAwait ? awaitKeyword : usingKeyword);
Conversion iDisposableConversion;
ImmutableArray <BoundLocalDeclaration> declarationsOpt = default;
BoundMultipleLocalDeclarations multipleDeclarationsOpt = null;
BoundExpression expressionOpt = null;
TypeSymbol declarationTypeOpt = null;
MethodSymbol disposeMethodOpt;
TypeSymbol awaitableTypeOpt;
if (isExpression)
{
expressionOpt = usingBinderOpt.BindTargetExpression(diagnostics, originalBinder);
hasErrors |= !populateDisposableConversionOrDisposeMethod(fromExpression: true, out iDisposableConversion, out disposeMethodOpt, out awaitableTypeOpt);
}
else
{
VariableDeclarationSyntax declarationSyntax = isUsingDeclaration ? ((LocalDeclarationStatementSyntax)syntax).Declaration : (VariableDeclarationSyntax)syntax;
originalBinder.BindForOrUsingOrFixedDeclarations(declarationSyntax, LocalDeclarationKind.UsingVariable, diagnostics, out declarationsOpt);
Debug.Assert(!declarationsOpt.IsEmpty);
multipleDeclarationsOpt = new BoundMultipleLocalDeclarations(declarationSyntax, declarationsOpt);
declarationTypeOpt = declarationsOpt[0].DeclaredTypeOpt.Type;
if (declarationTypeOpt.IsDynamic())
{
iDisposableConversion = Conversion.ImplicitDynamic;
disposeMethodOpt = null;
awaitableTypeOpt = null;
}
else
{
hasErrors |= !populateDisposableConversionOrDisposeMethod(fromExpression: false, out iDisposableConversion, out disposeMethodOpt, out awaitableTypeOpt);
}
}
BoundAwaitableInfo awaitOpt = null;
if (hasAwait)
{
// even if we don't have a proper value to await, we'll still report bad usages of `await`
originalBinder.ReportBadAwaitDiagnostics(syntax, awaitKeyword.GetLocation(), diagnostics, ref hasErrors);
if (awaitableTypeOpt is null)
{
awaitOpt = new BoundAwaitableInfo(syntax, awaitableInstancePlaceholder: null, isDynamic: true, getAwaiter: null, isCompleted: null, getResult: null)
{
WasCompilerGenerated = true
};
}
else
{
hasErrors |= ReportUseSiteDiagnostics(awaitableTypeOpt, diagnostics, awaitKeyword);
var placeholder = new BoundAwaitableValuePlaceholder(syntax, valEscape: originalBinder.LocalScopeDepth, awaitableTypeOpt).MakeCompilerGenerated();
awaitOpt = originalBinder.BindAwaitInfo(placeholder, syntax, diagnostics, ref hasErrors);
}
}
// This is not awesome, but its factored.
// In the future it might be better to have a separate shared type that we add the info to, and have the callers create the appropriate bound nodes from it
if (isUsingDeclaration)
{
return(new BoundUsingLocalDeclarations(syntax, disposeMethodOpt, iDisposableConversion, awaitOpt, declarationsOpt, hasErrors));
}
else
{
BoundStatement boundBody = originalBinder.BindPossibleEmbeddedStatement(usingBinderOpt._syntax.Statement, diagnostics);
return(new BoundUsingStatement(
usingBinderOpt._syntax,
usingBinderOpt.Locals,
multipleDeclarationsOpt,
expressionOpt,
iDisposableConversion,
boundBody,
awaitOpt,
disposeMethodOpt,
hasErrors));
}
bool populateDisposableConversionOrDisposeMethod(bool fromExpression, out Conversion iDisposableConversion, out MethodSymbol disposeMethodOpt, out TypeSymbol awaitableTypeOpt)
{
HashSet <DiagnosticInfo> useSiteDiagnostics = null;
iDisposableConversion = classifyConversion(fromExpression, disposableInterface, ref useSiteDiagnostics);
disposeMethodOpt = null;
awaitableTypeOpt = null;
diagnostics.Add(syntax, useSiteDiagnostics);
if (iDisposableConversion.IsImplicit)
{
if (hasAwait)
{
awaitableTypeOpt = originalBinder.Compilation.GetWellKnownType(WellKnownType.System_Threading_Tasks_ValueTask);
}
return(true);
}
TypeSymbol type = fromExpression ? expressionOpt.Type : declarationTypeOpt;
// If this is a ref struct, or we're in a valid asynchronous using, try binding via pattern.
// We won't need to try and bind a second time if it fails, as async dispose can't be pattern based (ref structs are not allowed in async methods)
if (type is object && (type.IsRefLikeType || hasAwait))
{
BoundExpression receiver = fromExpression
? expressionOpt
: new BoundLocal(syntax, declarationsOpt[0].LocalSymbol, null, type)
{
WasCompilerGenerated = true
};
DiagnosticBag patternDiagnostics = originalBinder.Compilation.IsFeatureEnabled(MessageID.IDS_FeatureUsingDeclarations)
? diagnostics
: new DiagnosticBag();
disposeMethodOpt = originalBinder.TryFindDisposePatternMethod(receiver, syntax, hasAwait, patternDiagnostics);
if (disposeMethodOpt is object)
{
MessageID.IDS_FeatureUsingDeclarations.CheckFeatureAvailability(diagnostics, originalBinder.Compilation, syntax.Location);
if (hasAwait)
{
awaitableTypeOpt = disposeMethodOpt.ReturnType;
}
return(true);
}
}
if (type is null || !type.IsErrorType())
{
// Retry with a different assumption about whether the `using` is async
TypeSymbol alternateInterface = getDisposableInterface(!hasAwait);
HashSet <DiagnosticInfo> ignored = null;
Conversion alternateConversion = classifyConversion(fromExpression, alternateInterface, ref ignored);
bool wrongAsync = alternateConversion.IsImplicit;
ErrorCode errorCode = wrongAsync
? (hasAwait ? ErrorCode.ERR_NoConvToIAsyncDispWrongAsync : ErrorCode.ERR_NoConvToIDispWrongAsync)
: (hasAwait ? ErrorCode.ERR_NoConvToIAsyncDisp : ErrorCode.ERR_NoConvToIDisp);
Error(diagnostics, errorCode, syntax, declarationTypeOpt ?? expressionOpt.Display);
}
return(false);
}
Conversion classifyConversion(bool fromExpression, TypeSymbol targetInterface, ref HashSet <DiagnosticInfo> diag)
{
return(fromExpression ?
originalBinder.Conversions.ClassifyImplicitConversionFromExpression(expressionOpt, targetInterface, ref diag) :
originalBinder.Conversions.ClassifyImplicitConversionFromType(declarationTypeOpt, targetInterface, ref diag));
}
TypeSymbol getDisposableInterface(bool isAsync)
{
return(isAsync
? originalBinder.Compilation.GetWellKnownType(WellKnownType.System_IAsyncDisposable)
: originalBinder.Compilation.GetSpecialType(SpecialType.System_IDisposable));
}
}
private static int FindLocalDeclarationStatementIndex(
WhileStatementSyntax whileStatement,
SyntaxList <StatementSyntax> statements,
int startIndex,
int count,
bool mustBeReferencedInsideWhileStatement,
SemanticModel semanticModel,
CancellationToken cancellationToken = default)
{
int result = -1;
int whileStatementIndex = -1;
ITypeSymbol typeSymbol = null;
for (int i = count - 1; i >= startIndex; i--)
{
StatementSyntax statement = statements[i];
if (!(statement is LocalDeclarationStatementSyntax localDeclaration))
{
return(result);
}
VariableDeclarationSyntax declaration = localDeclaration.Declaration;
foreach (VariableDeclaratorSyntax variable in declaration.Variables)
{
var symbol = (ILocalSymbol)semanticModel.GetDeclaredSymbol(variable, cancellationToken);
if (symbol == null)
{
continue;
}
if (symbol.Type.IsErrorType())
{
continue;
}
if (typeSymbol == null)
{
typeSymbol = symbol.Type;
}
else if (!typeSymbol.Equals(symbol.Type))
{
return(result);
}
ContainsLocalOrParameterReferenceWalker walker = ContainsLocalOrParameterReferenceWalker.GetInstance(symbol, semanticModel, cancellationToken);
if (mustBeReferencedInsideWhileStatement)
{
walker.VisitWhileStatement(whileStatement);
if (!walker.Result)
{
ContainsLocalOrParameterReferenceWalker.Free(walker);
return(result);
}
}
walker.Result = false;
if (whileStatementIndex == -1)
{
whileStatementIndex = statements.IndexOf(whileStatement);
}
walker.VisitList(statements, whileStatementIndex + 1);
if (ContainsLocalOrParameterReferenceWalker.GetResultAndFree(walker))
{
return(result);
}
result = i;
}
}
return(result);
}
void VisitDeclareVairable(DB_Type type, DB_Member method, DB_StatementSyntax statement, VariableDeclarationSyntax Declaration)
{
foreach (var e in Declaration.Variables)
{
model.AddLocal(e.Identifier, model.Finder.FindType(Declaration.Type, model));
model.VisitExp(this, type, method, statement, e.Initializer, null);
}
}
private BoundMultipleVariableDeclarations BindForStatementDeclaration(VariableDeclarationSyntax syntax, Symbol parent)
{
// When binding for loop declarations, allow redefinition of variables from enclosing scope. (X3078)
// Use most recently declared variable. Add a warning to diagnostics.
return BindVariableDeclaration(syntax, parent, (d, t) =>
{
List<Symbol> existingSymbols;
if (_symbols.TryGetValue(d.Identifier.Text, out existingSymbols))
{
existingSymbols.Remove(existingSymbols.Last());
if (!existingSymbols.Any())
_symbols.Remove(d.Identifier.Text);
Diagnostics.ReportLoopControlVariableConflict(d);
}
return new VariableSymbol(d, parent, t);
});
}
// 变量声明
public virtual void VisitVariableDeclarationSyntax(VariableDeclarationSyntax value)
{
DefaultVisit(value);
}
public virtual void VisitVariableDeclaration(VariableDeclarationSyntax node)
{
DefaultVisit(node);
}
public override void VisitVariableDeclaration(VariableDeclarationSyntax node)
{
VisitNodeToBind(node.Initializer);
}
public override void VisitVariableDeclaration(VariableDeclarationSyntax node)
{
var fieldInfo = node.Parent as FieldDeclarationSyntax;
var modifiers = fieldInfo.Modifiers;
bool bPublic = modifiers.Any(c => c.Kind == SyntaxKind.PublicKeyword);
string initValue = DefaultValueEmitter.FromType(node.Type.PlainName);
foreach (var variable in node.Variables)
{
var nodeName = variable.Identifier.GetText().ToLowerCamelCase();
if (variable.Initializer != null)
initValue = EmitExpression(variable.Initializer.Value);
//base.VisitVariableDeclaration(node);
if (bPublic)
_publicCode.WriteLine(" {0}: {1},", nodeName, initValue);
else
_writer.WriteLine(" var {0} = {1};", nodeName, initValue);
}
//base.VisitVariableDeclaration(node);
}
public LocalDeclarationSharpnode(VariableDeclarationSyntax stmt) : base(null)
{
Init(stmt);
}
private BoundMultipleVariableDeclarations BindVariableDeclaration(VariableDeclarationSyntax syntax, Symbol parent, Func<VariableDeclaratorSyntax, TypeSymbol, VariableSymbol> createSymbol)
{
var boundType = Bind(syntax.Type, x => BindType(x, parent));
var boundDeclarations = new List<BoundVariableDeclaration>();
foreach (var declarator in syntax.Variables)
{
boundDeclarations.Add(Bind(declarator, x => BindVariableDeclarator(x, boundType.TypeSymbol, createSymbol)));
}
return new BoundMultipleVariableDeclarations(boundDeclarations.ToImmutableArray());
}
protected abstract void CompileVariableDeclaration(VariableDeclarationSyntax declaration);
