/// <summary>
/// Rewrites the expression with a field access expression.
/// </summary>
/// <param name="node">IdentifierNameSyntax</param>
/// <returns>SyntaxNode</returns>
private SyntaxNode RewriteExpression(IdentifierNameSyntax node)
{
SyntaxNode rewritten = node;
if (!base.IsInStateScope(rewritten) ||
!(base.IsMachineField(rewritten) || base.IsMachineMethod(rewritten)))
{
return rewritten;
}
if (!(rewritten.Parent is MemberAccessExpressionSyntax) &&
!(rewritten.Parent is ObjectCreationExpressionSyntax) &&
!(rewritten.Parent is TypeOfExpressionSyntax))
{
var text = "this." + node.ToString();
rewritten = SyntaxFactory.ParseExpression(text);
rewritten = rewritten.WithTriviaFrom(node);
}
if ((rewritten.Parent is MemberAccessExpressionSyntax) &&
(rewritten.Parent as MemberAccessExpressionSyntax).Expression is IdentifierNameSyntax &&
((rewritten.Parent as MemberAccessExpressionSyntax).Expression as IdentifierNameSyntax).
IsEquivalentTo(node))
{
var text = "this." + node.ToString();
rewritten = SyntaxFactory.ParseExpression(text);
rewritten = rewritten.WithTriviaFrom(node);
}
return rewritten;
}
private Document IntroduceLocalDeclarationIntoLambda(
SemanticDocument document,
ExpressionSyntax expression,
IdentifierNameSyntax newLocalName,
LocalDeclarationStatementSyntax declarationStatement,
SyntaxNode oldLambda,
bool allOccurrences,
CancellationToken cancellationToken)
{
var oldBody = oldLambda is ParenthesizedLambdaExpressionSyntax
? (ExpressionSyntax)((ParenthesizedLambdaExpressionSyntax)oldLambda).Body
: (ExpressionSyntax)((SimpleLambdaExpressionSyntax)oldLambda).Body;
var rewrittenBody = Rewrite(
document, expression, newLocalName, document, oldBody, allOccurrences, cancellationToken);
var delegateType = document.SemanticModel.GetTypeInfo(oldLambda, cancellationToken).ConvertedType as INamedTypeSymbol;
var newBody = delegateType != null && delegateType.DelegateInvokeMethod != null && delegateType.DelegateInvokeMethod.ReturnsVoid
? SyntaxFactory.Block(declarationStatement)
: SyntaxFactory.Block(declarationStatement, SyntaxFactory.ReturnStatement(rewrittenBody));
newBody = newBody.WithAdditionalAnnotations(Formatter.Annotation);
var newLambda = oldLambda is ParenthesizedLambdaExpressionSyntax
? ((ParenthesizedLambdaExpressionSyntax)oldLambda).WithBody(newBody)
: (SyntaxNode)((SimpleLambdaExpressionSyntax)oldLambda).WithBody(newBody);
var newRoot = document.Root.ReplaceNode(oldLambda, newLambda);
return document.Document.WithSyntaxRoot(newRoot);
}
public override void VisitIdentifierName(IdentifierNameSyntax node)
{
base.VisitIdentifierName(node);
var symbol = nodeContext.SemanticModel.GetSymbolInfo(node).Symbol;
if (symbol.IsKind(SymbolKind.TypeParameter))
UsedTypeParameters.Add(symbol);
}
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node)
{
if (!(node.Parent is MemberAccessExpressionSyntax) || ((MemberAccessExpressionSyntax)node.Parent).Expression == node)
{
if (node.GetContainingMethod() == null)
{
return base.VisitIdentifierName(node);
}
var containingType = node.GetContainingType();
if (containingType == null || !containingType.Name.StartsWith(enclosingTypeName))
return node;
var symbol = semanticModel.GetSymbolInfo(node).Symbol;
var isObjectInitializer = node.Parent != null && node.Parent.Parent is InitializerExpressionSyntax;
if (!isObjectInitializer)
{
if (symbol == null || (new[] { SymbolKind.Field, SymbolKind.Event, SymbolKind.Method, SymbolKind.Property }.Contains(symbol.Kind) && !symbol.ContainingType.Name.StartsWith(enclosingTypeName) && !symbol.IsStatic))
{
return SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("_this"), node);
}
}
}
return base.VisitIdentifierName(node);
}
private static void AnalyzeTypeNode(
SyntaxNodeAnalysisContext context,
Location location,
IdentifierNameSyntax typeNode) {
if (typeNode == null || typeNode.IsVar) return;
var classSymbol = context.SemanticModel.GetSymbolInfo(typeNode).Symbol as INamedTypeSymbol;
if (classSymbol == null) return;
if (classSymbol.TypeKind != TypeKind.Class) return;
if (classSymbol.AllInterfaces.Count() != 1) return;
if (!classSymbol.CanBeReferencedByName) return;
var interfaceSymbol = classSymbol.AllInterfaces.Single();
if (!interfaceSymbol.CanBeReferencedByName) return;
context.ReportDiagnostic(
Diagnostic.Create(
Rule,
location,
properties: ImmutableDictionary.Create<string, string>()
.Add("interfaceName", interfaceSymbol.Name)
.Add("interfaceNamespace", interfaceSymbol.ContainingNamespace.Name)
.Add("className", classSymbol.Name),
messageArgs: new[] { classSymbol.Name, interfaceSymbol.Name }
));
}
private void AnalyzeMemberAccessExpressionsCsharp(SyntaxNodeAnalysisContext context)
{
var memberAccessExpression = (CSSyntax.MemberAccessExpressionSyntax)context.Node;
// If the accessed member isn't named "Current" bail out
if (!TargetMember.Equals(memberAccessExpression.Name.Identifier.ValueText, StringComparison.Ordinal))
{
return;
}
// If the call is to a method called Current then bail out since they're
// not using the HttpContext.Current property
if (memberAccessExpression.Parent is CSSyntax.InvocationExpressionSyntax)
{
return;
}
// Get the identifier accessed
var accessedIdentifier = memberAccessExpression.Expression switch
{
CSSyntax.IdentifierNameSyntax i => i,
CSSyntax.MemberAccessExpressionSyntax m => m.DescendantNodes().OfType <CSSyntax.IdentifierNameSyntax>().LastOrDefault(),
_ => null
};
AnalyzeMemberAccessExpressions(context, memberAccessExpression, accessedIdentifier, accessedIdentifier?.Identifier.ValueText);
}
//--- Class Methods ---
public static IEnumerable<ISymbol> GetMissingEnumMembers(SwitchStatementSyntax switchNode, SemanticModel semanticModel, out IdentifierNameSyntax switchVariable)
{
// TODO (2016-02-25, steveb): what if the swich calls a function instead?
switchVariable = switchNode.Expression as IdentifierNameSyntax;
if(switchVariable == null) {
return Enumerable.Empty<ISymbol>();
}
var switchVariableTypeInfo = semanticModel.GetTypeInfo(switchVariable);
// check if we are switching over an enum
if((switchVariableTypeInfo.Type != null) && (switchVariableTypeInfo.Type.TypeKind == TypeKind.Enum)) {
// get all the enum values
var enumMembers = switchVariableTypeInfo.Type.GetMembers().Where(x => x.Kind == SymbolKind.Field).ToImmutableArray();
// get all case statements
var caseSwitchLabels = switchNode.Sections
.SelectMany(section => section.Labels)
.Select(label => label.DescendantNodes().OfType<MemberAccessExpressionSyntax>().FirstOrDefault())
.Where(memberAccess => memberAccess != null)
.Select(memberAccess => semanticModel.GetSymbolInfo(memberAccess).Symbol)
.ToImmutableHashSet();
// make sure we have all cases covered
return enumMembers.Where(x => !caseSwitchLabels.Contains(x)).ToImmutableArray();
}
return Enumerable.Empty<ISymbol>();
}
private async Task<Document> InsertStopwatchToMeasureTime(Document document, IdentifierNameSyntax node, CancellationToken cancellationToken) {
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken);
var nodes = new List<Tuple<SyntaxNode, SyntaxNode>>();
SyntaxNode nodeLine = GetRootNodeOfLine(node);
SyntaxNode newNode = CommentLine(nodeLine);
newNode = newNode.WithTrailingTrivia(newNode.GetTrailingTrivia()
.AddRange(nodeLine.GetLeadingTrivia())
.Add(SyntaxFactory.SyntaxTrivia(SyntaxKind.SingleLineCommentTrivia, "timer.Stop();"))
.Add(SyntaxFactory.EndOfLine(Environment.NewLine))
.AddRange(nodeLine.GetLeadingTrivia())
.Add(SyntaxFactory.SyntaxTrivia(SyntaxKind.SingleLineCommentTrivia, "TimeSpan elapsed = timer.Elapsed;"))
.Add(SyntaxFactory.EndOfLine(Environment.NewLine)));
nodes.Add(new Tuple<SyntaxNode, SyntaxNode>(nodeLine, newNode));
var methodDeclaration = node.FirstAncestorOfType(typeof(MethodDeclarationSyntax)) as MethodDeclarationSyntax;
if (semanticModel == null) { return document; }
SyntaxNode firstGetTime = TimeMeasurementCodeAnalyzer.GetNodesUsedToGetCurrentTime(semanticModel, methodDeclaration).First();
nodeLine = GetRootNodeOfLine(firstGetTime);
newNode = CommentLine(nodeLine);
newNode = newNode.WithTrailingTrivia(newNode.GetTrailingTrivia()
.AddRange(nodeLine.GetLeadingTrivia())
.Add(SyntaxFactory.SyntaxTrivia(SyntaxKind.SingleLineCommentTrivia, "var timer = Stopwatch.StartNew();"))
.Add(SyntaxFactory.EndOfLine(Environment.NewLine)));
nodes.Add(new Tuple<SyntaxNode, SyntaxNode>(nodeLine, newNode));
document = await this.ReplaceNodesInDocumentAsync(document, cancellationToken, nodes.ToArray());
return await this.CheckNamespaceUsageAsync(document, cancellationToken, "System.Diagnostics");
}
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node)
{
if (node.Identifier.ToString() == renameFrom.ToString())
return SyntaxFactory.IdentifierName(renameTo);
return base.VisitIdentifierName(node);
}
/// <summary>
/// Examines the identifier and if applicable, creates an instance of ObjectInformation
/// which will be consumed later by the SyntaxBuilder
/// </summary>
/// <param name="node"></param>
private void processIdentifierName(IdentifierNameSyntax node)
{
var symbol = _model.GetSymbolInfo(node).Symbol;
var type = _model.GetTypeInfo(node).Type;
if (type == null || symbol == null)
{
// We need a symbol
// Method names are an example of identifiers with no types, and we ignore them
return;
}
if (node.IsVar)
{
return;
}
if (symbol != null)
{
var typeName = type?.Name ?? String.Empty;
// Handle generics (TODO: recursively go through all levels)
var namedType = type as INamedTypeSymbol;
if (namedType != null)
{
List<string> argumentNames = new List<string>();
foreach (var argument in namedType.TypeArguments)
{
var argumentName = argument.Name;
argumentNames.Add(argumentName);
}
if (argumentNames.Any())
{
typeName = $"{type?.Name}<{String.Join(", ", argumentNames)}>";
}
}
// Attempt to remove trivial identifiers like String.Empty
var definitionName = symbol.OriginalDefinition.ToDisplayString();
var actualName = typeName + "." + symbol.MetadataName;
if (String.Compare(definitionName, actualName, ignoreCase: true) == 0)
{
// This identifier is already well defined in the snippet.
return;
}
foreach (var location in symbol.OriginalDefinition.Locations)
{
// Process only nodes defined outside of the target range
if (!location.IsInSource || !(location.SourceSpan.Start < _end && location.SourceSpan.End > _start))
{
var objectInfo = new ObjectInformation()
{
Identifier = node?.Identifier.ToString() ?? String.Empty,
TypeName = typeName ?? String.Empty,
Namespace = type?.ContainingNamespace?.ToString() ?? String.Empty,
AssemblyName = type?.ContainingAssembly?.Name ?? String.Empty,
Kind = symbol.Kind,
};
definedWithinSnippet.Add(objectInfo);
}
}
}
}
protected NavInvocationAnnotation(NavTaskAnnotation taskAnnotation,
IdentifierNameSyntax identifier): base(taskAnnotation) {
if(identifier == null) {
throw new ArgumentNullException(nameof(identifier));
}
Identifier = identifier;
}
/// <summary>
/// Rewrites the expression with a trigger expression.
/// </summary>
/// <param name="node">IdentifierNameSyntax</param>
/// <returns>SyntaxNode</returns>
private SyntaxNode RewriteExpression(IdentifierNameSyntax node)
{
var text = "this.ReceivedEvent";
var rewritten = SyntaxFactory.ParseExpression(text);
rewritten = rewritten.WithTriviaFrom(node);
return rewritten;
}
/// <summary>
/// Called by the base class. Processes identifiers that are in desired range.
/// </summary>
/// <param name="node"></param>
public override void VisitIdentifierName(IdentifierNameSyntax node)
{
// Process only nodes in the target range
if (node.Span.Start < _end && node.Span.End > _start)
{
processIdentifierName(node);
}
}
public ExceptionReference(ISymbol symbol, IdentifierNameSyntax identifier)
{
Contract.Requires(symbol != null);
Contract.Requires(identifier != null);
Symbol = symbol;
Identifier = identifier;
}
/// <summary>
/// Rewrites the type with a halt event type.
/// </summary>
/// <param name="node">IdentifierNameSyntax</param>
/// <returns>ExpressionSyntax</returns>
private ExpressionSyntax RewriteType(IdentifierNameSyntax node)
{
var text = typeof(Halt).FullName;
var rewritten = SyntaxFactory.ParseName(text);
rewritten = rewritten.WithTriviaFrom(node);
return rewritten;
}
/// <summary>
/// Create If statement that execute yield return if not completed the <see cref="Task"/> or <see cref="Task{T}"/> object.
/// </summary>
/// <remarks>
/// if (!task.IsCompleted)
/// yield return task;
/// </remarks>
private static SyntaxNode CreateYieldReturnIfNotCompleted(IdentifierNameSyntax task)
{
return SyntaxFactory.IfStatement(
SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, SyntaxFactory.Token(SyntaxKind.ExclamationToken),
SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, task, SyntaxFactory.IdentifierName("IsCompleted"))
),
SyntaxFactory.YieldStatement(SyntaxKind.YieldReturnStatement, task)
);
}
/// <summary>
/// Rewrites the type with a halt event type.
/// </summary>
/// <param name="node">IdentifierNameSyntax</param>
/// <returns>ExpressionSyntax</returns>
private ExpressionSyntax RewriteType(IdentifierNameSyntax node)
{
var text = "Halt";
var rewritten = SyntaxFactory.ParseExpression(text);
rewritten = rewritten.WithTriviaFrom(node);
return rewritten;
}
private async Task<Document> ApplyReplacement(Document document, IdentifierNameSyntax node, CancellationToken cancellationToken, string replaceWithName, string namespaceUsed) {
IdentifierNameSyntax newNode = SyntaxFactory.IdentifierName(replaceWithName)
.WithLeadingTrivia(node.GetLeadingTrivia())
.WithTrailingTrivia(node.GetTrailingTrivia());
var oldNode = node.Parent.Kind() == SyntaxKind.SimpleMemberAccessExpression ? node.Parent : node;
document = await this.ReplaceNodeInDocumentAsync(document, cancellationToken, oldNode, newNode);
return await this.CheckNamespaceUsageAsync(document, cancellationToken, namespaceUsed);
}
public override void VisitIdentifierName(IdentifierNameSyntax node)
{
base.VisitIdentifierName(node);
if (!IsTargetOfInvocation(node)) {
var mgr = ctx.GetSymbolInfo(node);
if (mgr.Symbol?.IsKind(SymbolKind.Method) == true)
UsedMethods.Add(mgr.Symbol);
}
}
public NavInitCallAnnotation(NavTaskAnnotation taskAnnotation,
IdentifierNameSyntax identifier,
string beginItfFullyQualifiedName,
List<string> parameter)
: base(taskAnnotation, identifier) {
BeginItfFullyQualifiedName = beginItfFullyQualifiedName ?? String.Empty;
Parameter = (parameter ?? new List<string>()).ToImmutableList();
}
public override void VisitIdentifierName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax node)
{
base.VisitIdentifierName(node);
ISymbol symbol = null;
if (node.IsVar)
{
if (node.Parent is ForEachStatementSyntax)
{
var sym = semanticModel.GetDeclaredSymbol(node.Parent, cancellationToken);
if (sym != null)
{
Colorize(node.Span, varKeywordTypeColor);
return;
}
}
var vds = node.Parent as VariableDeclarationSyntax;
if (vds != null && vds.Variables.Count == 1)
{
symbol = semanticModel.GetSymbolInfo(node, cancellationToken).Symbol;
// var sym = vds.Variables[0].Initializer != null ? vds.Variables[0].Initializer.Value as LiteralExpressionSyntax : null;
// This is done to support highlighting when there is a class named var. The problem is that var is
// not a reserved keyword. The trade-off is really big, but for correctness, we have to handle this
// case.
if (symbol == null || symbol.Name != "var")
{
Colorize(node.Span, varKeywordTypeColor);
return;
}
}
}
if (contextualKeywords.Contains(node.Identifier.Text))
{
// Reset color of contextual keyword to default if it's used as an identifier.
// Note that this method does not get called when 'var' or 'dynamic' is used as a type,
// because types get highlighted with valueTypeColor/referenceTypeColor instead.
Colorize(node.Span, defaultTextColor);
return;
}
// "value" is handled in VisitIdentifierExpression()
// "alias" is handled in VisitExternAliasDeclaration()
TColor color;
if (TryGetSymbolColor(symbol ?? semanticModel.GetSymbolInfo(node, cancellationToken).Symbol, out color))
{
if (node.Parent is AttributeSyntax || node.Parent is QualifiedNameSyntax && node.Parent.Parent is AttributeSyntax)
{
color = referenceTypeColor;
}
Colorize(node.Span, color);
}
}
public RootedStructGen(CodeGen generator)
: base(generator)
{
this.typeName = GetRootedTypeSyntax(this.applyTo);
if (!this.applyTo.RecursiveTypeFromFamily.IsDefault)
{
this.rootedRecursiveType = GetRootedTypeSyntax(this.applyTo.RecursiveTypeFromFamily);
this.rootedRecursiveParent = GetRootedTypeSyntax(this.applyTo.RecursiveParent);
}
}
public override void VisitIdentifierName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax node)
{
if (node.ToString() == identifier)
{
var symbol = model.GetSymbolInfo(node).Symbol;
if (symbol != null)
{
symbols.Add(symbol);
}
}
base.VisitIdentifierName(node);
}
private async Task<Solution> UseTypeExplicit(Document document, IdentifierNameSyntax identifierName, TypeInfo typeInfo, CancellationToken cancellationToken)
{
var root = await document.GetSyntaxRootAsync();
var newIdentifierName =
SyntaxFactory.ParseTypeName(typeInfo.ConvertedType.ToString())
.WithAdditionalAnnotations(Simplifier.Annotation)
.WithLeadingTrivia(identifierName.GetLeadingTrivia())
.WithTrailingTrivia(identifierName.GetTrailingTrivia());
var newDocument = document.WithSyntaxRoot(root.ReplaceNode(identifierName, newIdentifierName));
return newDocument.Project.Solution;
}
public override void VisitIdentifierName(IdentifierNameSyntax node)
{
var s = "";
var up = node.HasParent<VariableDeclarationSyntax, FieldDeclarationSyntax>();
if (up == null)
{ }
else
{
s = "var ";
}
_2JS.Append(s);
base.VisitIdentifierName(node);
}
protected override void VisitIdentiferNameSyntax(IdentifierNameSyntax node)
{
Type type = node.GetType();
List<ArgumentSyntax> arguments = new List<ArgumentSyntax>();
List<SyntaxToken> separators = new List<SyntaxToken>();
string value = ((NameSyntax)node).ToString();
ExpressionSyntax exp = SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal("\"" + value + "\"", value));
arguments.Add(CreateArgument(exp));
BuildSyntaxNode(identifier.GetId(node), type, "IdentifierName", arguments, separators, null);
base.VisitIdentiferNameSyntax(node);
}
public DeltaGen(CodeGen generator)
: base(generator)
{
var recursiveType = this.applyTo.RecursiveTypeFromFamily;
if (!recursiveType.IsDefault)
{
this.changedPropertiesEnumTypeName = SyntaxFactory.IdentifierName(recursiveType.TypeSymbol.Name + "ChangedProperties");
this.diffGramTypeSyntax = SyntaxFactory.QualifiedName(recursiveType.TypeSyntax, DiffGramTypeName);
this.recursiveDiffingType = SyntaxFactory.QualifiedName(
SyntaxFactory.IdentifierName(nameof(ImmutableObjectGraph)),
SyntaxFactory.GenericName(nameof(ImmutableObjectGraph.IRecursiveDiffingType<uint, uint>))
.AddTypeArgumentListArguments(
this.changedPropertiesEnumTypeName,
this.diffGramTypeSyntax));
}
}
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node)
{
if (IsReference(node))
{
var assignmentExpression = node.Parent as AssignmentExpressionSyntax;
if (assignmentExpression != null)
{
if (assignmentExpression.IsCompoundAssignExpression() &&
assignmentExpression.Left == node)
{
return node.Update(node.Identifier.WithAdditionalAnnotations(CreateConflictAnnotation()));
}
}
}
return base.VisitIdentifierName(node);
}
/// <summary>
/// Rewrites the expression with a field access expression.
/// </summary>
/// <param name="node">IdentifierNameSyntax</param>
/// <returns>SyntaxNode</returns>
private SyntaxNode RewriteExpression(IdentifierNameSyntax node)
{
SyntaxNode rewritten = node;
if (!base.IsInStateScope(rewritten) ||
!(base.IsMachineField(rewritten) || base.IsMachineMethod(rewritten)))
{
return rewritten;
}
if (rewritten.Parent is ArgumentSyntax &&
rewritten.Parent.Parent is ArgumentListSyntax &&
rewritten.Parent.Parent.Parent is InvocationExpressionSyntax)
{
var invocation = rewritten.Parent.Parent.Parent as InvocationExpressionSyntax;
if (invocation.Expression is IdentifierNameSyntax &&
(invocation.Expression as IdentifierNameSyntax).Identifier.ValueText.Equals("nameof") &&
invocation.ArgumentList.Arguments.Count == 1)
{
return rewritten;
}
}
if (!(rewritten.Parent is MemberAccessExpressionSyntax) &&
!(rewritten.Parent is ObjectCreationExpressionSyntax) &&
!(rewritten.Parent is TypeOfExpressionSyntax))
{
var text = "this." + node.ToString();
rewritten = SyntaxFactory.ParseExpression(text);
rewritten = rewritten.WithTriviaFrom(node);
}
if ((rewritten.Parent is MemberAccessExpressionSyntax) &&
(rewritten.Parent as MemberAccessExpressionSyntax).Expression is IdentifierNameSyntax &&
((rewritten.Parent as MemberAccessExpressionSyntax).Expression as IdentifierNameSyntax).
IsEquivalentTo(node))
{
var text = "this." + node.ToString();
rewritten = SyntaxFactory.ParseExpression(text);
rewritten = rewritten.WithTriviaFrom(node);
}
return rewritten;
}
bool IsModified(IdentifierNameSyntax identifier)
{
if (identifier.Parent.IsKind(SyntaxKind.PreDecrementExpression) ||
identifier.Parent.IsKind(SyntaxKind.PostDecrementExpression) ||
identifier.Parent.IsKind(SyntaxKind.PreIncrementExpression) ||
identifier.Parent.IsKind(SyntaxKind.PostIncrementExpression))
return true;
var assignment = identifier.Parent as AssignmentExpressionSyntax;
if (assignment != null && assignment.Left == identifier)
return true;
var arg = identifier.Parent as ArgumentSyntax;
if (arg != null && (arg.RefOrOutKeyword.IsKind(SyntaxKind.RefKeyword) || arg.RefOrOutKeyword.IsKind(SyntaxKind.OutKeyword)))
return true;
return false;
}
/// <summary>
/// Rewrites the expression with a payload expression.
/// </summary>
/// <param name="node">IdentifierNameSyntax</param>
/// <returns>SyntaxNode</returns>
private SyntaxNode RewriteExpression(IdentifierNameSyntax node)
{
var text = "";
if (node.Parent is ElementAccessExpressionSyntax)
{
text = "((object[])this.Payload)";
}
else
{
text = "this.Payload";
}
var rewritten = SyntaxFactory.ParseExpression(text);
rewritten = rewritten.WithTriviaFrom(node);
return rewritten;
}
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node)
{
_cancellationToken.ThrowIfCancellationRequested();
if (IsReference(node))
{
if (HasConflict(node, _variableDeclarator))
{
return node.Update(node.Identifier.WithAdditionalAnnotations(CreateConflictAnnotation()));
}
return _expressionToInline
.Parenthesize()
.WithAdditionalAnnotations(Formatter.Annotation, Simplifier.Annotation);
}
return base.VisitIdentifierName(node);
}
public static string IdentifierName(IdentifierNameSyntax identifierName)
{
//Looks for an ExportAttribute
var symbol = Model.GetSymbolInfo(identifierName).Symbol;
string nameToUse = null;
if (symbol != null)
{
//Check for an [Export()] attribute
var exportAttr = symbol.GetAttributes().FirstOrDefault(attr => attr.AttributeClass.Name.Contains("ExportAttribute"));
if (exportAttr != null)
{
nameToUse = exportAttr.ConstructorArguments[0].Value.ToString();
}
}
return nameToUse ?? Type(identifierName.Identifier.Text);
}
public static glsl.IdentifierNameSyntax Translate(this cs.IdentifierNameSyntax node)
{
return(new glsl.IdentifierNameSyntax().Update(
node.Identifier
));
}
public override void VisitIdentifierName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax node)
{
base.VisitIdentifierName(node);
ISymbol symbol = null;
if (node.IsVar)
{
if (node.Parent is ForEachStatementSyntax)
{
var sym = semanticModel.GetDeclaredSymbol(node.Parent, cancellationToken);
if (sym != null)
{
Colorize(node.Span, varKeywordTypeColor);
return;
}
}
var vds = node.Parent as VariableDeclarationSyntax;
if (vds != null && vds.Variables.Count == 1)
{
symbol = semanticModel.GetSymbolInfo(node, cancellationToken).Symbol;
// var sym = vds.Variables[0].Initializer != null ? vds.Variables[0].Initializer.Value as LiteralExpressionSyntax : null;
// This is done to support highlighting when there is a class named var. The problem is that var is
// not a reserved keyword. The trade-off is really big, but for correctness, we have to handle this
// case.
if (symbol == null || symbol.Name != "var")
{
Colorize(node.Span, varKeywordTypeColor);
return;
}
}
}
switch (node.Identifier.Text)
{
case "add":
case "async":
case "await":
case "get":
case "partial":
case "remove":
case "set":
case "where":
case "yield":
case "from":
case "select":
case "group":
case "into":
case "orderby":
case "join":
case "let":
case "on":
case "equals":
case "by":
case "ascending":
case "descending":
// Reset color of contextual keyword to default if it's used as an identifier.
// Note that this method does not get called when 'var' or 'dynamic' is used as a type,
// because types get highlighted with valueTypeColor/referenceTypeColor instead.
Colorize(node.Span, defaultTextColor);
break;
case "global":
// // Reset color of 'global' keyword to default unless its used as part of 'global::'.
// MemberType parentMemberType = identifier.Parent as MemberType;
// if (parentMemberType == null || !parentMemberType.IsDoubleColon)
Colorize(node.Span, defaultTextColor);
break;
}
// "value" is handled in VisitIdentifierExpression()
// "alias" is handled in VisitExternAliasDeclaration()
TColor color;
if (TryGetSymbolColor(symbol ?? semanticModel.GetSymbolInfo(node, cancellationToken).Symbol, out color))
{
if (node.Parent is AttributeSyntax || node.Parent is QualifiedNameSyntax && node.Parent.Parent is AttributeSyntax)
{
color = referenceTypeColor;
}
Colorize(node.Span, color);
}
}
public override VisualBasicSyntaxNode VisitIdentifierName(CSS.IdentifierNameSyntax node)
{
return(SyntaxFactory.IdentifierName(ConvertIdentifier(node.Identifier)));
}
public override VB.VisualBasicSyntaxNode VisitIdentifierName(CSS.IdentifierNameSyntax node)
{
var Identifier = VBFactory.IdentifierName(node.Identifier.ToString());
return(Identifier);
}
/// <summary>
/// Gets the target of the provided <paramref name="expression"/> using the provided <paramref name="symbol"/> and <paramref name="model"/>.
/// </summary>
/// <param name="expression">An <see cref="InvocationExpressionSyntax"/> instance describing the invocation of a particular method.</param>
/// <param name="symbol">An <see cref="IMethodSymbol"/> describing the method being invoked by the <paramref name="expression"/>.</param>
/// <param name="model">A <see cref="SemanticModel"/> that can be used to resolve type information.</param>
/// <param name="context">An <see cref="InvokedMethod"/> that represents the context in which to determine the target of the invocation.</param>
/// <returns>Returns a <see cref="TypeInfo"/> instance representing the type of the target being invoked, or <c>null</c> if the type could not be determined.</returns>
public static TypeInfo?GetTargetOfInvocation(this InvocationExpressionSyntax expression, IMethodSymbol symbol, SemanticModel model, InvokedMethod context)
{
TypeInfo?targetTypeInfo = expression.Expression.Kind() == SyntaxKind.IdentifierName ? context.TargetType : expression.GetTargetType(model, context);
if (targetTypeInfo.HasValue)
{
MemberAccessExpressionSyntax memberAccess = expression.Expression as MemberAccessExpressionSyntax;
IdentifierNameSyntax identifier = memberAccess?.Expression as IdentifierNameSyntax ?? expression.Expression as IdentifierNameSyntax;
if (identifier != null)
{
SymbolInfo identifierSymbol = model.GetSymbolInfo(identifier);
switch (identifierSymbol.Symbol.Kind)
{
case SymbolKind.Local:
VariableDeclaratorSyntax syntax = identifierSymbol.Symbol.GetComparableSyntax()?.GetSyntax() as VariableDeclaratorSyntax;
if (syntax != null && syntax.ChildNodes().Any())
{
targetTypeInfo = model.GetTypeInfo(syntax.ChildNodes().First().ChildNodes().First());
}
break;
case SymbolKind.Parameter:
if (context.Method != null)
{
var parameter = context.Method.Parameters.FirstOrDefault(p => p.Name == identifierSymbol.Symbol.Name);
var parameterIndex = context.Method.Parameters.IndexOf(parameter);
targetTypeInfo = context.ArgumentTypes.ElementAt(parameterIndex);
}
break;
case SymbolKind.Field:
SyntaxNode node = expression.Parent;
while (!(node is BlockSyntax))
{
node = node.Parent;
}
var statementsInBlock = node.ChildNodes().ToList();
var currentStatementIndex = statementsInBlock.IndexOf(expression.Parent);
var assignments = statementsInBlock.Take(currentStatementIndex)
.OfType <ExpressionStatementSyntax>()
.Where(s => s.Expression.IsKind(SyntaxKind.SimpleAssignmentExpression))
.Select(s => s.Expression as AssignmentExpressionSyntax)
.Where(s => model.GetSymbolInfo(s.Left).Symbol == identifierSymbol.Symbol);
AssignmentExpressionSyntax lastAssignment = assignments.LastOrDefault();
if (lastAssignment != null)
{
targetTypeInfo = model.GetTypeInfo(lastAssignment.Right);
}
break;
default:
break;
}
}
}
return(targetTypeInfo);
}
