private static void RegisterRefactoring(RefactoringContext context, ParameterSyntax parameter)
{
RegisterRefactoring(context, ImmutableArray.Create(parameter), $"'{parameter.Identifier.ValueText}'");
}
/// <inheritdoc />
public override ClassDeclarationSyntax Apply(ClassDeclarationSyntax node, INamedTypeSymbol symbol, CancellationToken cancellationToken)
{
var parameters = ImmutableArray.CreateBuilder <ParameterSyntax>();
var arguments = ImmutableArray.CreateBuilder <ArgumentSyntax>();
var ctorStmts = ImmutableArray.CreateBuilder <StatementSyntax>();
// Generate all parameters and statements
var members = symbol.GetMembers();
for (int i = 0; i < members.Length; i++)
{
IPropertySymbol member = members[i] as IPropertySymbol;
if (member == null || !member.IsReadOnly || !member.CanBeReferencedByName)
{
continue;
}
// Read-only prop, we good
string propName = member.Name;
string paramName = $"{char.ToLower(propName[0]).ToString()}{propName.Substring(1)}";
TypeSyntax paramType = ((PropertyDeclarationSyntax)member.DeclaringSyntaxReferences[0]
.GetSyntax(cancellationToken)).Type;
MemberAccessExpressionSyntax propAccess = F.MemberAccessExpression(
K.SimpleMemberAccessExpression,
F.ThisExpression(),
F.IdentifierName(propName)
);
// Make parameter & argument
parameters.Add(F.Parameter(F.Identifier(paramName)).WithType(paramType));
arguments.Add(F.Argument(propAccess));
// Make ctor stmt
ctorStmts.Add(F.ExpressionStatement(
F.AssignmentExpression(K.SimpleAssignmentExpression,
propAccess,
F.IdentifierName(paramName)
)
));
}
// The ctor is full, make all the 'with' methods
TypeSyntax returnType = F.IdentifierName(symbol.Name);
MemberDeclarationSyntax[] additionalMethods = new MemberDeclarationSyntax[parameters.Count + 1];
arguments.Capacity = arguments.Count;
ImmutableArray <ArgumentSyntax> args = arguments.MoveToImmutable();
for (int i = 0; i < parameters.Count; i++)
{
ParameterSyntax parameter = parameters[i];
string parameterName = parameter.Identifier.Text;
ArgumentSyntax name = F.Argument(F.IdentifierName(parameterName));
SeparatedSyntaxList <ArgumentSyntax> allArguments = F.SeparatedList(args.Replace(args[i], name));
StatementSyntax returnStmt = F.ReturnStatement(
F.ObjectCreationExpression(returnType).WithArgumentList(F.ArgumentList(allArguments))
);
additionalMethods[i] = F.MethodDeclaration(returnType, $"With{char.ToUpper(parameterName[0]).ToString()}{parameterName.Substring(1)}")
.AddModifiers(F.Token(K.PublicKeyword), F.Token(K.NewKeyword))
.AddParameterListParameters(parameter)
.AddBodyStatements(returnStmt);
}
// Add the private ctor
additionalMethods[parameters.Count] = F.ConstructorDeclaration(symbol.Name)
.AddModifiers(F.Token(K.PrivateKeyword))
.AddParameterListParameters(parameters.ToArray())
.AddBodyStatements(ctorStmts.ToArray());
return(node.AddMembers(additionalMethods));
}
// ParameterSyntax
public virtual bool WalkParameter(ParameterSyntax parameterSyntax) { return DefaultWalk(parameterSyntax); }
private static IEnumerable <SyntaxNode> GetParameterInitializersAndAttributes(ParameterSyntax parameter) => SpecializedCollections.SingletonEnumerable(parameter.Default).Concat(GetAttributes(parameter.AttributeLists));
internal LambdaExpressionWithSingleParameter(ParameterSyntax parameter, CSharpSyntaxNode body)
: this()
{
Parameter = parameter;
Body = body;
}
public virtual void VisitParameter(ParameterSyntax node)
{
DefaultVisit(node);
}
public BoundParameter(string name, IType type, ParameterSyntax parameterSyntax)
: base(parameterSyntax)
{
Name = name;
Type = type;
}
public override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindToken(root, context.Span.Start, out SyntaxToken token))
{
return;
}
SyntaxNode node = token.Parent;
if (!CSharpFacts.CanHaveModifiers(node.Kind()))
{
node = node.FirstAncestor(f => CSharpFacts.CanHaveModifiers(f.Kind()));
}
Debug.Assert(node != null, $"{nameof(node)} is null");
if (node == null)
{
return;
}
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case CompilerDiagnosticIdentifiers.ModifierIsNotValidForThisItem:
{
if (!Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveInvalidModifier))
{
break;
}
SyntaxTokenList modifiers = SyntaxInfo.ModifierListInfo(node).Modifiers;
if (modifiers.Contains(token))
{
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, token);
break;
}
else if (IsInterfaceMemberOrExplicitInterfaceImplementation(node))
{
ModifiersCodeFixRegistrator.RemoveModifiers(
context,
diagnostic,
node,
modifiers,
f =>
{
switch (f.Kind())
{
case SyntaxKind.PublicKeyword:
case SyntaxKind.ProtectedKeyword:
case SyntaxKind.InternalKeyword:
case SyntaxKind.PrivateKeyword:
case SyntaxKind.StaticKeyword:
case SyntaxKind.VirtualKeyword:
case SyntaxKind.OverrideKeyword:
case SyntaxKind.AbstractKeyword:
{
return(true);
}
}
return(false);
});
}
else if (node.IsKind(SyntaxKind.MethodDeclaration, SyntaxKind.PropertyDeclaration, SyntaxKind.IndexerDeclaration, SyntaxKind.EventDeclaration, SyntaxKind.EventFieldDeclaration) &&
node.IsParentKind(SyntaxKind.StructDeclaration) &&
modifiers.Contains(SyntaxKind.VirtualKeyword))
{
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.VirtualKeyword);
}
else if (node.IsKind(SyntaxKind.IndexerDeclaration) &&
modifiers.Contains(SyntaxKind.StaticKeyword))
{
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.StaticKeyword);
}
else if (node.IsKind(SyntaxKind.PropertyDeclaration, SyntaxKind.IndexerDeclaration, SyntaxKind.EventDeclaration, SyntaxKind.EventFieldDeclaration) &&
modifiers.Contains(SyntaxKind.AsyncKeyword))
{
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.AsyncKeyword);
}
break;
}
case CompilerDiagnosticIdentifiers.MoreThanOneProtectionModifier:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveInvalidModifier))
{
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, token);
}
break;
}
case CompilerDiagnosticIdentifiers.AccessibilityModifiersMayNotBeUsedOnAccessorsInInterface:
case CompilerDiagnosticIdentifiers.AccessModifiersAreNotAllowedOnStaticConstructors:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveInvalidModifier))
{
ModifiersCodeFixRegistrator.RemoveAccessibility(context, diagnostic, node);
}
break;
}
case CompilerDiagnosticIdentifiers.ModifiersCannotBePlacedOnEventAccessorDeclarations:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveInvalidModifier))
{
ModifiersCodeFixRegistrator.RemoveModifiers(context, diagnostic, node);
}
break;
}
case CompilerDiagnosticIdentifiers.OnlyMethodsClassesStructsOrInterfacesMayBePartial:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveInvalidModifier))
{
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.PartialKeyword);
}
break;
}
case CompilerDiagnosticIdentifiers.ClassCannotBeBothStaticAndSealed:
{
if (!Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveInvalidModifier))
{
break;
}
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.StaticKeyword, additionalKey: nameof(SyntaxKind.StaticKeyword));
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.SealedKeyword, additionalKey: nameof(SyntaxKind.SealedKeyword));
break;
}
case CompilerDiagnosticIdentifiers.FieldCanNotBeBothVolatileAndReadOnly:
{
if (!Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveInvalidModifier))
{
break;
}
var fieldDeclaration = (FieldDeclarationSyntax)node;
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, fieldDeclaration, SyntaxKind.VolatileKeyword, additionalKey: nameof(SyntaxKind.VolatileKeyword));
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, fieldDeclaration, SyntaxKind.ReadOnlyKeyword, additionalKey: nameof(SyntaxKind.ReadOnlyKeyword));
break;
}
case CompilerDiagnosticIdentifiers.NewProtectedMemberDeclaredInSealedClass:
case CompilerDiagnosticIdentifiers.StaticClassesCannotContainProtectedMembers:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.ChangeAccessibility))
{
ModifiersCodeFixRegistrator.ChangeAccessibility(context, diagnostic, node, _publicOrInternalOrPrivate);
}
break;
}
case CompilerDiagnosticIdentifiers.VirtualOrAbstractMembersCannotBePrivate:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveVirtualModifier))
{
ModifierListInfo modifierInfo = SyntaxInfo.ModifierListInfo(node);
if (modifierInfo.IsVirtual)
{
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.VirtualKeyword, additionalKey: nameof(SyntaxKind.VirtualKeyword));
}
}
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.ChangeAccessibility))
{
ModifiersCodeFixRegistrator.ChangeAccessibility(context, diagnostic, node, _publicOrInternalOrProtected);
}
break;
}
case CompilerDiagnosticIdentifiers.AbstractPropertiesCannotHavePrivateAccessors:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveInvalidModifier))
{
ModifiersCodeFixRegistrator.RemoveAccessibility(context, diagnostic, node, additionalKey: CodeFixIdentifiers.RemoveInvalidModifier);
}
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.ChangeAccessibility))
{
ModifiersCodeFixRegistrator.ChangeAccessibility(context, diagnostic, node, _publicOrInternalOrProtected);
}
break;
}
case CompilerDiagnosticIdentifiers.StaticMemberCannotBeMarkedOverrideVirtualOrAbstract:
{
if (!Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveInvalidModifier))
{
break;
}
if (!node.IsParentKind(SyntaxKind.ClassDeclaration) ||
!((ClassDeclarationSyntax)node.Parent).Modifiers.Contains(SyntaxKind.StaticKeyword))
{
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.StaticKeyword, additionalKey: nameof(SyntaxKind.StaticKeyword));
}
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.OverrideKeyword, additionalKey: nameof(SyntaxKind.OverrideKeyword));
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.VirtualKeyword, additionalKey: nameof(SyntaxKind.VirtualKeyword));
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.AbstractKeyword, additionalKey: nameof(SyntaxKind.AbstractKeyword));
break;
}
case CompilerDiagnosticIdentifiers.AsyncModifierCanOnlyBeUsedInMethodsThatHaveBody:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveInvalidModifier))
{
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.AsyncKeyword);
}
break;
}
case CompilerDiagnosticIdentifiers.PartialMethodCannotHaveAccessModifiersOrVirtualAbstractOverrideNewSealedOrExternModifiers:
{
if (!Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveInvalidModifier))
{
break;
}
ModifiersCodeFixRegistrator.RemoveModifiers(
context,
diagnostic,
node,
f =>
{
switch (f.Kind())
{
case SyntaxKind.PublicKeyword:
case SyntaxKind.ProtectedKeyword:
case SyntaxKind.InternalKeyword:
case SyntaxKind.PrivateKeyword:
case SyntaxKind.VirtualKeyword:
case SyntaxKind.AbstractKeyword:
case SyntaxKind.OverrideKeyword:
case SyntaxKind.NewKeyword:
case SyntaxKind.SealedKeyword:
case SyntaxKind.ExternKeyword:
{
return(true);
}
}
return(false);
});
break;
}
case CompilerDiagnosticIdentifiers.ExtensionMethodMustBeStatic:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.AddStaticModifier))
{
AddStaticModifier(context, diagnostic, node, CodeFixIdentifiers.AddStaticModifier);
}
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveThisModifier))
{
var methodDeclaration = (MethodDeclarationSyntax)node;
ParameterSyntax parameter = methodDeclaration.ParameterList.Parameters[0];
SyntaxToken modifier = parameter.Modifiers.Find(SyntaxKind.ThisKeyword);
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, parameter, modifier, additionalKey: CodeFixIdentifiers.RemoveThisModifier);
}
break;
}
case CompilerDiagnosticIdentifiers.ExtensionMethodMustBeDefinedInNonGenericStaticClass:
{
if (!(node is ClassDeclarationSyntax classDeclaration))
{
return;
}
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.AddStaticModifier) &&
!classDeclaration.Modifiers.Contains(SyntaxKind.StaticKeyword))
{
AddStaticModifier(context, diagnostic, node, CodeFixIdentifiers.AddStaticModifier);
}
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveThisModifier))
{
IEnumerable <ParameterSyntax> thisParameters = classDeclaration.Members
.Where(f => f.IsKind(SyntaxKind.MethodDeclaration))
.Cast <MethodDeclarationSyntax>()
.Select(f => f.ParameterList?.Parameters.FirstOrDefault())
.Where(f => f?.Modifiers.Contains(SyntaxKind.ThisKeyword) == true);
ModifiersCodeFixRegistrator.RemoveModifier(
context,
diagnostic,
thisParameters,
SyntaxKind.ThisKeyword,
title: "Remove 'this' modifier from extension methods",
additionalKey: CodeFixIdentifiers.RemoveThisModifier);
}
break;
}
case CompilerDiagnosticIdentifiers.NoDefiningDeclarationFoundForImplementingDeclarationOfPartialMethod:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveInvalidModifier))
{
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.PartialKeyword);
}
break;
}
case CompilerDiagnosticIdentifiers.MethodHasParameterModifierThisWhichIsNotOnFirstParameter:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveThisModifier))
{
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, token.Parent, token);
}
break;
}
case CompilerDiagnosticIdentifiers.CannotDeclareInstanceMembersInStaticClass:
case CompilerDiagnosticIdentifiers.StaticClassesCannotHaveInstanceConstructors:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.AddStaticModifier))
{
AddStaticModifier(context, diagnostic, node, CodeFixIdentifiers.AddStaticModifier);
}
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.MakeContainingClassNonStatic))
{
var classDeclaration = (ClassDeclarationSyntax)node.Parent;
ModifiersCodeFixRegistrator.RemoveModifier(
context,
diagnostic,
classDeclaration,
classDeclaration.Modifiers.Find(SyntaxKind.StaticKeyword),
title: "Make containing class non-static",
additionalKey: CodeFixIdentifiers.MakeContainingClassNonStatic);
}
break;
}
case CompilerDiagnosticIdentifiers.ElementsDefinedInNamespaceCannotBeExplicitlyDeclaredAsPrivateProtectedOrProtectedInternal:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.ChangeAccessibility))
{
ModifiersCodeFixRegistrator.ChangeAccessibility(context, diagnostic, node, _publicOrInternal);
}
break;
}
case CompilerDiagnosticIdentifiers.NamespaceAlreadyContainsDefinition:
case CompilerDiagnosticIdentifiers.TypeAlreadyContainsDefinition:
{
if (!Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.AddPartialModifier))
{
break;
}
if (!node.IsKind(
SyntaxKind.ClassDeclaration,
SyntaxKind.StructDeclaration,
SyntaxKind.InterfaceDeclaration,
SyntaxKind.MethodDeclaration))
{
return;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ISymbol symbol = semanticModel.GetDeclaredSymbol(node, context.CancellationToken);
ImmutableArray <SyntaxReference> syntaxReferences = symbol.DeclaringSyntaxReferences;
if (syntaxReferences.Length <= 1)
{
break;
}
ModifiersCodeFixRegistrator.AddModifier(
context,
diagnostic,
ImmutableArray.CreateRange(syntaxReferences, f => f.GetSyntax(context.CancellationToken)),
SyntaxKind.PartialKeyword,
title: $"Make {CSharpFacts.GetTitle(node)} partial");
break;
}
case CompilerDiagnosticIdentifiers.NoSuitableMethodFoundToOverride:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveInvalidModifier))
{
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.OverrideKeyword);
}
break;
}
case CompilerDiagnosticIdentifiers.AsyncMethodsCannotHaveRefOrOutParameters:
case CompilerDiagnosticIdentifiers.IteratorsCannotHaveRefOrOutParameters:
case CompilerDiagnosticIdentifiers.ReadOnlyFieldCannotBePassedAsRefOrOutValue:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveRefModifier))
{
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.RefKeyword, additionalKey: nameof(SyntaxKind.RefKeyword));
}
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveOutModifier))
{
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.OutKeyword, additionalKey: nameof(SyntaxKind.OutKeyword));
}
break;
}
case CompilerDiagnosticIdentifiers.CannotHaveInstancePropertyOrFieldInitializersInStruct:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.AddStaticModifier))
{
AddStaticModifier(context, diagnostic, node);
}
break;
}
case CompilerDiagnosticIdentifiers.MemberMustDeclareBodyBecauseItIsNotMarkedAbstractExternOrPartial:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.AddModifierAbstract) &&
node.Kind() == SyntaxKind.MethodDeclaration &&
(node.Parent as ClassDeclarationSyntax)?.Modifiers.Contains(SyntaxKind.AbstractKeyword) == true)
{
ModifiersCodeFixRegistrator.AddModifier(context, diagnostic, node, SyntaxKind.AbstractKeyword);
}
break;
}
case CompilerDiagnosticIdentifiers.NewVirtualMemberInSealedClass:
{
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveVirtualModifier))
{
if (node is AccessorDeclarationSyntax &&
SyntaxInfo.ModifierListInfo(node.Parent.Parent).IsVirtual)
{
node = node.Parent.Parent;
}
ModifiersCodeFixRegistrator.RemoveModifier(
context,
diagnostic,
node,
SyntaxKind.VirtualKeyword,
additionalKey: CodeFixIdentifiers.RemoveVirtualModifier);
}
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.MakeContainingClassUnsealed) &&
node.Parent is ClassDeclarationSyntax classDeclaration)
{
ModifiersCodeFixRegistrator.RemoveModifier(
context,
diagnostic,
classDeclaration,
SyntaxKind.SealedKeyword,
title: "Make containing class unsealed",
additionalKey: CodeFixIdentifiers.MakeContainingClassUnsealed);
}
break;
}
case CompilerDiagnosticIdentifiers.InstanceFieldsOfReadOnlyStructsMustBeReadOnly:
{
if (!Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.MakeMemberReadOnly))
{
break;
}
ModifiersCodeFixRegistrator.AddModifier(context, diagnostic, node, SyntaxKind.ReadOnlyKeyword);
break;
}
case CompilerDiagnosticIdentifiers.MemberCannotBeSealedBecauseItIsNotOverride:
{
if (!Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveSealedModifier))
{
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
if (semanticModel.GetDiagnostic(
CompilerDiagnosticIdentifiers.MemberHidesInheritedMemberToMakeCurrentMethodOverrideThatImplementationAddOverrideKeyword,
CSharpUtility.GetIdentifier(node).Span,
context.CancellationToken) != null)
{
break;
}
ModifiersCodeFixRegistrator.RemoveModifier(context, diagnostic, node, SyntaxKind.SealedKeyword);
break;
}
}
}
}
public AdaptInterfaceCodeAction(IDocument document, ClassDeclarationSyntax classDeclaration, ParameterSyntax parameterSyntax)
{
this._document = document;
_classDeclaration = classDeclaration;
Description = "Adapt "+parameterSyntax.Type;
}
public void VisitParameter(ParameterSyntax node)
{
if (node == null)
throw new ArgumentNullException("node");
node.Validate();
switch (node.Modifier)
{
case ParameterModifier.Ref:
_writer.WriteKeyword(PrinterKeyword.Ref);
_writer.WriteSpace();
break;
case ParameterModifier.Out:
_writer.WriteKeyword(PrinterKeyword.Out);
_writer.WriteSpace();
break;
}
if (node.Type != null)
{
node.Type.Accept(this);
_writer.WriteSpace();
}
_writer.WriteIdentifier(node.Identifier);
if (node.Default != null)
node.Default.Accept(this);
}
public override void VisitParameter(ParameterSyntax node)
{
map.Add(node.Identifier.ValueText, node.Identifier);
base.VisitParameter(node);
}
private Variables TraverseParameters(ParameterSyntax vds)
{
Variables retVar = new Variables();
retVar.Name = vds.Identifier.ToString();
retVar.IsReferenced = false;
//Encapsulation
foreach (SyntaxToken st in vds.Modifiers)
{
string modifier = System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(st.ValueText);
Encapsulation encap;
Qualifiers qual;
if (System.Enum.TryParse<Encapsulation>(modifier, out encap))
{
retVar.Accessibility.Add(encap);
}
else if (System.Enum.TryParse<Qualifiers>(modifier, out qual))
{
retVar.Qualifiers.Add(qual);
}
}
AsClauseSyntax acs = vds.AsClause;
TypeSyntax ts = acs.Type();
Model.Type type = new Model.Type();
type.Name = ts.ToString();
type.IsKnownType = SyntaxFacts.IsKeywordKind(ts.VisualBasicKind());
type.IsNotUserDefined = SyntaxFacts.IsKeywordKind(ts.VisualBasicKind());
return retVar;
}
private BoundParameter BindParameter(ParameterSyntax syntax)
{
var boundType = syntax.Type.TypeSwitchExpression<TypeSyntax, IType>()
.Case<ArrayTypeSyntax>(BindArrayType)
.Case<TypeSyntax>(BindType)
.Default(() => { throw new NotImplementedException(); })
.Done();
var boundParameter = new BoundParameter(syntax.Name.Value, boundType, syntax);
_contextService.AddLocal(boundParameter.Name, boundParameter);
return boundParameter;
}
private static MemberDeclarationSyntax GetMethodDeclaration(Module module, Function function, bool withBody)
{
var responseType = function.Result.GetMethodReturnType();
var responseDeclaration = responseType == null ? "Task" : $"Task<{responseType}>";
var requestParam = new { name = default(string), type = default(string) };
var callbackParam = new { name = default(string), nameWithNull = default(string), type = default(string) };
foreach (Param param in function.Params)
{
if (param.Type == ParamType.Generic && param.GenericName == ParamGenericName.Arc)
{
GenericArg arcArg = param.GenericArgs[0];
if (arcArg.Type == GenericArgType.Ref && arcArg.RefName == "Request")
{
var name = StringUtils.EscapeReserved(function.Params[2].Name.GetEnumMemberValueOrString());
callbackParam = new
{
name,
nameWithNull = $"{name} = null",
type = string.Equals(module.Name, "net", StringComparison.OrdinalIgnoreCase)
? "JsonElement"
: NamingConventions.EventFormatter(module.Name)
};
}
}
if (param.Type == ParamType.Generic && param.GenericName == ParamGenericName.AppObject)
{
callbackParam = new
{
name = "appObject",
nameWithNull = "appObject = null",
type = "JsonElement"
}
}
;
if (param.Name == Name.Params)
{
requestParam = new
{
name = StringUtils.EscapeReserved(function.Params[1].Name.GetEnumMemberValueOrString()),
type = GetParamType(function.Params[1])
}
}
;
}
var functionSummary = function.Summary + (function.Description != null ? $"\n{function.Description}" : null);
var modifiers = new List <SyntaxToken> {
Token(SyntaxKind.PublicKeyword).WithLeadingTrivia(CommentsHelpers.BuildCommentTrivia(functionSummary))
};
if (withBody)
{
modifiers.Add(Token(SyntaxKind.AsyncKeyword));
}
var @params = new List <ParameterSyntax>();
var methodDeclarationParams = new List <ParameterSyntax>();
if (requestParam.name != default)
{
ParameterSyntax param = Parameter(Identifier(requestParam.name)).WithType(IdentifierName(requestParam.type));
methodDeclarationParams.Add(param);
@params.Add(param);
}
if (callbackParam.name != default)
{
methodDeclarationParams.Add(Parameter(Identifier(callbackParam.nameWithNull)).WithType(IdentifierName($"Action<{callbackParam.type},uint>")));
@params.Add(Parameter(Identifier(callbackParam.name)).WithType(IdentifierName($"Action<{callbackParam.type},uint>")));
}
MethodDeclarationSyntax method =
MethodDeclaration(ParseTypeName(responseDeclaration), NamingConventions.Normalize(function.Name))
.AddParameterListParameters(methodDeclarationParams.ToArray())
.AddParameterListParameters(Parameter(Identifier("cancellationToken"))
.WithType(IdentifierName(nameof(CancellationToken)))
.WithDefault(EqualsValueClause(IdentifierName("default"))))
.AddModifiers(modifiers.ToArray());
if (withBody)
{
var arguments = new List <ArgumentSyntax>
{
Argument(IdentifierName($"\"{module.Name}.{function.Name}\""))
};
arguments.AddRange(
@params
.Select(p => Argument(IdentifierName(p.Identifier.Text))));
arguments.Add(Argument(IdentifierName("cancellationToken")));
var genericParametersDeclaration =
StringUtils.GetGenericParametersDeclaration(requestParam?.type, responseType, callbackParam?.type);
AwaitExpressionSyntax awaitExpression = AwaitExpression(
InvocationExpression(IdentifierName($"_tonClientAdapter.Request{genericParametersDeclaration}"))
.AddArgumentListArguments(arguments.ToArray()));
StatementSyntax ex = responseType == null
? ExpressionStatement(awaitExpression)
: ReturnStatement(awaitExpression);
BlockSyntax blockSyntax = Block(ex);
return(method.WithBody(blockSyntax));
}
return(method.WithSemicolonToken(Token(SyntaxKind.SemicolonToken)));
}
public virtual void Visit(ParameterSyntax parameterSyntax)
{
}
public static SyntaxNode IntroduceFieldFromConstructor(SyntaxNode root, ConstructorDeclarationSyntax constructorStatement, ParameterSyntax parameter)
{
var oldClass = constructorStatement.FirstAncestorOrSelf <ClassDeclarationSyntax>();
var newClass = oldClass;
var fieldName = parameter.Identifier.ValueText;
var fieldType = parameter.Type;
var members = ExtractMembersFromClass(oldClass.Members);
if (!members.Any(p => p.Key == fieldName && p.Value == fieldType.ToString()))
{
var identifierPostFix = 0;
while (members.Any(p => p.Key == fieldName))
{
fieldName = parameter.Identifier.ValueText + ++identifierPostFix;
}
var newField = SyntaxFactory.FieldDeclaration(SyntaxFactory.VariableDeclaration(parameter.Type)
.WithVariables(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(fieldName)))))
.WithModifiers(SyntaxFactory.TokenList(new[] { SyntaxFactory.Token(SyntaxKind.PrivateKeyword), SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword) }))
.WithAdditionalAnnotations(Formatter.Annotation);
newClass = newClass.WithMembers(newClass.Members.Insert(0, newField)).WithoutAnnotations(Formatter.Annotation);
}
var assignmentField = SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ThisExpression(),
SyntaxFactory.IdentifierName(fieldName)), SyntaxFactory.IdentifierName(parameter.Identifier.ValueText)));
var newConstructor = constructorStatement.WithBody(constructorStatement.Body.AddStatements(assignmentField));
newClass = newClass.ReplaceNode(newClass.DescendantNodes().OfType <ConstructorDeclarationSyntax>().First(), newConstructor);
var newRoot = root.ReplaceNode(oldClass, newClass);
return(newRoot);
}
protected ParameterSymbol GetSymbol(ParameterSyntax syntax, Dictionary<SyntaxTree, SemanticModel> models)
{
return syntax == null ? null : GetModel(syntax, models).GetDeclaredSymbol(syntax);
}
void CompileSamplerParameter(ParameterSyntax parameter, TypeSymbol symbol)
{
SamplerNumber++;
string name = parameter.Identifier.ValueText;
string mapped_name = FragmentShaderParameterPrefix + name;
var sampler_base = GetSamplerBase(symbol);
string address_u = TypeToAddress(sampler_base.TypeArguments[1]);
string address_v = TypeToAddress(sampler_base.TypeArguments[2]);
string min_filter = TypeToFilter(sampler_base.TypeArguments[3]);
string mag_filter = TypeToFilter(sampler_base.TypeArguments[4]);
string mip_filter = TypeToFilter(sampler_base.TypeArguments[5]);
Write(SamplerTemplate, Tab, SamplerNumber, mapped_name, address_u, address_v, min_filter, mag_filter, mip_filter);
var param = new Param("Texture2D", "shader", name, mapped_name, Param.ParamType.FragmentParam);
Params.Add(param);
AllParams.Add(param);
}
private bool IsWrittenTo(SyntaxNodeAnalysisContext context, MethodDeclarationSyntax methodDeclarationSyntax, ParameterSyntax parameterSyntax)
{
var semanticModel = context.SemanticModel;
var targetSymbol = semanticModel.GetDeclaredSymbol(parameterSyntax);
if (targetSymbol is null)
{
return(true);
}
DataFlowAnalysis flow;
if (methodDeclarationSyntax.Body != null)
{
if (!methodDeclarationSyntax.Body.Statements.Any())
{
return(false);
}
flow = semanticModel.AnalyzeDataFlow(methodDeclarationSyntax.Body.Statements.First(), methodDeclarationSyntax.Body.Statements.Last());
}
else if (methodDeclarationSyntax.ExpressionBody != null)
{
flow = semanticModel.AnalyzeDataFlow(methodDeclarationSyntax.ExpressionBody.Expression);
}
else
{
return(true);
}
bool isWrittenInside = flow.WrittenInside.Contains(targetSymbol);
return(isWrittenInside);
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddArgumentList) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ReorderModifiers) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ReplaceNullLiteralExpressionWithDefaultValue) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ReturnDefaultValue) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddMissingType) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.RemoveSemicolon) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.RemoveConditionalAccess) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ChangeForEachType) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddDefaultValueToParameter) &&
!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ChangeParameterType))
{
return;
}
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindToken(root, context.Span.Start, out SyntaxToken token))
{
return;
}
SyntaxKind kind = token.Kind();
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case CompilerDiagnosticIdentifiers.OperatorCannotBeAppliedToOperand:
{
if (kind == SyntaxKind.QuestionToken &&
token.Parent is ConditionalAccessExpressionSyntax conditionalAccess)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(conditionalAccess.Expression, context.CancellationToken);
if (typeSymbol?.IsErrorType() == false &&
!typeSymbol.IsNullableType())
{
if (typeSymbol.IsValueType)
{
if (Settings.IsCodeFixEnabled(CodeFixIdentifiers.RemoveConditionalAccess))
{
CodeAction codeAction = CodeAction.Create(
"Remove '?' operator",
cancellationToken =>
{
var textChange = new TextChange(token.Span, "");
return(context.Document.WithTextChangeAsync(textChange, cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
}
}
else if (typeSymbol.IsReferenceType)
{
if (Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddArgumentList) &&
conditionalAccess.WhenNotNull is MemberBindingExpressionSyntax memberBindingExpression)
{
ConditionalAccessExpressionSyntax newNode = conditionalAccess.WithWhenNotNull(
InvocationExpression(
memberBindingExpression.WithoutTrailingTrivia(),
ArgumentList().WithTrailingTrivia(memberBindingExpression.GetTrailingTrivia())));
CodeAction codeAction = CodeAction.Create(
"Add argument list",
cancellationToken => context.Document.ReplaceNodeAsync(conditionalAccess, newNode, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
}
}
}
if (Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddArgumentList))
{
break;
}
if (Settings.IsCodeFixEnabled(CodeFixIdentifiers.RemoveConditionalAccess))
{
}
}
break;
}
case CompilerDiagnosticIdentifiers.PartialModifierCanOnlyAppearImmediatelyBeforeClassStructInterfaceOrVoid:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ReorderModifiers))
{
break;
}
ModifiersCodeFixRegistrator.MoveModifier(context, diagnostic, token.Parent, token);
break;
}
case CompilerDiagnosticIdentifiers.ValueCannotBeUsedAsDefaultParameter:
{
if (!Settings.IsAnyCodeFixEnabled(CodeFixIdentifiers.ReplaceNullLiteralExpressionWithDefaultValue, CodeFixIdentifiers.ChangeParameterType))
{
break;
}
if (!(token.Parent is ParameterSyntax parameter))
{
break;
}
ExpressionSyntax value = parameter.Default?.Value;
if (value == null)
{
break;
}
if (value.IsKind(SyntaxKind.NullLiteralExpression))
{
if (Settings.IsCodeFixEnabled(CodeFixIdentifiers.ReplaceNullLiteralExpressionWithDefaultValue))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
CodeFixRegistrator.ReplaceNullWithDefaultValue(context, diagnostic, value, semanticModel);
}
}
else if (!value.IsKind(SyntaxKind.DefaultExpression, SyntaxKind.DefaultLiteralExpression))
{
if (Settings.IsCodeFixEnabled(CodeFixIdentifiers.ChangeParameterType))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(value, context.CancellationToken);
if (!typeSymbol.IsKind(SymbolKind.ErrorType))
{
CodeFixRegistrator.ChangeType(context, diagnostic, parameter.Type, typeSymbol, semanticModel);
}
}
}
break;
}
case CompilerDiagnosticIdentifiers.ObjectOfTypeConvertibleToTypeIsRequired:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ReturnDefaultValue))
{
break;
}
if (token.Kind() != SyntaxKind.ReturnKeyword)
{
break;
}
if (!token.IsParentKind(SyntaxKind.ReturnStatement))
{
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ISymbol symbol = semanticModel.GetEnclosingSymbol(token.SpanStart, context.CancellationToken);
if (symbol == null)
{
break;
}
SymbolKind symbolKind = symbol.Kind;
ITypeSymbol typeSymbol = null;
if (symbolKind == SymbolKind.Method)
{
var methodSymbol = (IMethodSymbol)symbol;
typeSymbol = methodSymbol.ReturnType;
if (methodSymbol.IsAsync &&
(typeSymbol is INamedTypeSymbol namedTypeSymbol))
{
ImmutableArray <ITypeSymbol> typeArguments = namedTypeSymbol.TypeArguments;
if (typeArguments.Any())
{
typeSymbol = typeArguments[0];
}
}
}
else if (symbolKind == SymbolKind.Property)
{
typeSymbol = ((IPropertySymbol)symbol).Type;
}
else
{
Debug.Fail(symbolKind.ToString());
}
if (typeSymbol == null)
{
break;
}
if (typeSymbol.Kind == SymbolKind.ErrorType)
{
break;
}
if (!typeSymbol.SupportsExplicitDeclaration())
{
break;
}
var returnStatement = (ReturnStatementSyntax)token.Parent;
CodeAction codeAction = CodeAction.Create(
"Return default value",
cancellationToken =>
{
ExpressionSyntax expression = typeSymbol.GetDefaultValueSyntax(semanticModel, returnStatement.SpanStart);
ReturnStatementSyntax newNode = returnStatement.WithExpression(expression);
return(context.Document.ReplaceNodeAsync(returnStatement, newNode, cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.TypeExpected:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddMissingType))
{
break;
}
if (token.Kind() != SyntaxKind.CloseParenToken)
{
break;
}
if (!(token.Parent is DefaultExpressionSyntax defaultExpression))
{
break;
}
if (!(defaultExpression.Type is IdentifierNameSyntax identifierName))
{
break;
}
if (!identifierName.IsMissing)
{
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
TypeInfo typeInfo = semanticModel.GetTypeInfo(defaultExpression, context.CancellationToken);
ITypeSymbol convertedType = typeInfo.ConvertedType;
if (convertedType?.SupportsExplicitDeclaration() != true)
{
break;
}
CodeAction codeAction = CodeAction.Create(
$"Add type '{SymbolDisplay.ToMinimalDisplayString(convertedType, semanticModel, defaultExpression.SpanStart, SymbolDisplayFormats.Default)}'",
cancellationToken =>
{
TypeSyntax newNode = convertedType.ToMinimalTypeSyntax(semanticModel, defaultExpression.SpanStart);
newNode = newNode
.WithTriviaFrom(identifierName)
.WithFormatterAnnotation();
return(context.Document.ReplaceNodeAsync(identifierName, newNode, cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case CompilerDiagnosticIdentifiers.SemicolonAfterMethodOrAccessorBlockIsNotValid:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.RemoveSemicolon))
{
break;
}
if (token.Kind() != SyntaxKind.SemicolonToken)
{
break;
}
switch (token.Parent)
{
case MethodDeclarationSyntax methodDeclaration:
{
BlockSyntax body = methodDeclaration.Body;
if (body == null)
{
break;
}
CodeAction codeAction = CodeAction.Create(
"Remove semicolon",
cancellationToken =>
{
SyntaxTriviaList trivia = body
.GetTrailingTrivia()
.EmptyIfWhitespace()
.AddRange(token.LeadingTrivia.EmptyIfWhitespace())
.AddRange(token.TrailingTrivia);
MethodDeclarationSyntax newNode = methodDeclaration
.WithBody(body.WithTrailingTrivia(trivia))
.WithSemicolonToken(default(SyntaxToken));
return(context.Document.ReplaceNodeAsync(methodDeclaration, newNode, cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case PropertyDeclarationSyntax propertyDeclaration:
{
AccessorListSyntax accessorList = propertyDeclaration.AccessorList;
if (accessorList == null)
{
break;
}
CodeAction codeAction = CodeAction.Create(
"Remove semicolon",
cancellationToken =>
{
SyntaxTriviaList trivia = accessorList
.GetTrailingTrivia()
.EmptyIfWhitespace()
.AddRange(token.LeadingTrivia.EmptyIfWhitespace())
.AddRange(token.TrailingTrivia);
PropertyDeclarationSyntax newNode = propertyDeclaration
.WithAccessorList(accessorList.WithTrailingTrivia(trivia))
.WithSemicolonToken(default(SyntaxToken));
return(context.Document.ReplaceNodeAsync(propertyDeclaration, newNode, cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case AccessorDeclarationSyntax accessorDeclaration:
{
BlockSyntax body = accessorDeclaration.Body;
if (body == null)
{
break;
}
CodeAction codeAction = CodeAction.Create(
"Remove semicolon",
cancellationToken =>
{
SyntaxTriviaList trivia = body
.GetTrailingTrivia()
.EmptyIfWhitespace()
.AddRange(token.LeadingTrivia.EmptyIfWhitespace())
.AddRange(token.TrailingTrivia);
AccessorDeclarationSyntax newNode = accessorDeclaration
.WithBody(body.WithTrailingTrivia(trivia))
.WithSemicolonToken(default(SyntaxToken));
return(context.Document.ReplaceNodeAsync(accessorDeclaration, newNode, cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
}
break;
}
case CompilerDiagnosticIdentifiers.CannotConvertType:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ChangeForEachType))
{
break;
}
if (token.Kind() != SyntaxKind.ForEachKeyword)
{
break;
}
if (!(token.Parent is ForEachStatementSyntax forEachStatement))
{
break;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ForEachStatementInfo info = semanticModel.GetForEachStatementInfo(forEachStatement);
ITypeSymbol typeSymbol = info.ElementType;
if (typeSymbol.SupportsExplicitDeclaration())
{
CodeFixRegistrator.ChangeType(context, diagnostic, forEachStatement.Type, typeSymbol, semanticModel, CodeFixIdentifiers.ChangeForEachType);
}
CodeFixRegistrator.ChangeTypeToVar(context, diagnostic, forEachStatement.Type, CodeFixIdentifiers.ChangeTypeToVar);
break;
}
case CompilerDiagnosticIdentifiers.OptionalParametersMustAppearAfterAllRequiredParameters:
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.AddDefaultValueToParameter))
{
break;
}
if (!(token.Parent is BaseParameterListSyntax parameterList))
{
break;
}
SeparatedSyntaxList <ParameterSyntax> parameters = parameterList.Parameters;
ParameterSyntax parameter = null;
for (int i = 0; i < parameters.Count; i++)
{
ParameterSyntax p = parameters[i];
if (p.FullSpan.End <= token.SpanStart)
{
parameter = p;
}
else
{
break;
}
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
IParameterSymbol parameterSymbol = semanticModel.GetDeclaredSymbol(parameter, context.CancellationToken);
ITypeSymbol typeSymbol = parameterSymbol.Type;
if (typeSymbol.Kind == SymbolKind.ErrorType)
{
break;
}
CodeAction codeAction = CodeAction.Create(
"Add default value",
cancellationToken =>
{
ExpressionSyntax defaultValue = typeSymbol.GetDefaultValueSyntax(semanticModel, parameter.SpanStart);
ParameterSyntax newParameter = parameter
.WithDefault(EqualsValueClause(defaultValue).WithTrailingTrivia(parameter.GetTrailingTrivia()))
.WithoutTrailingTrivia()
.WithFormatterAnnotation();
return(context.Document.ReplaceNodeAsync(parameter, newParameter, cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
}
}
}
public static void AnalyzeSimpleLambdaExpression(SyntaxNodeAnalysisContext context)
{
if (context.Node.SpanContainsDirectives())
{
return;
}
var lambda = (SimpleLambdaExpressionSyntax)context.Node;
InvocationExpressionSyntax invocationExpression = GetInvocationExpression(lambda.Body);
if (invocationExpression == null)
{
return;
}
ExpressionSyntax expression = invocationExpression.Expression;
if (!IsSimpleInvocation(expression))
{
return;
}
SemanticModel semanticModel = context.SemanticModel;
CancellationToken cancellationToken = context.CancellationToken;
if (!(semanticModel.GetSymbol(invocationExpression, cancellationToken) is IMethodSymbol methodSymbol))
{
return;
}
bool isReduced = methodSymbol.MethodKind == MethodKind.ReducedExtension;
if (!methodSymbol.IsStatic &&
expression.Kind() != SyntaxKind.IdentifierName)
{
if (!ExpressionIsParameter(expression, lambda.Parameter))
{
return;
}
else if (isReduced &&
!context.ContainingSymbol.ContainingType.Equals(methodSymbol.ContainingType))
{
return;
}
}
ImmutableArray <IParameterSymbol> parameterSymbols = (isReduced) ? methodSymbol.ReducedFrom.Parameters : methodSymbol.Parameters;
if (parameterSymbols.Length != 1)
{
return;
}
ArgumentListSyntax argumentList = invocationExpression.ArgumentList;
SeparatedSyntaxList <ArgumentSyntax> arguments = argumentList.Arguments;
if (arguments.Count != ((isReduced) ? 0 : 1))
{
return;
}
ParameterSyntax parameter = lambda.Parameter;
MemberAccessExpressionSyntax memberAccessExpression = (isReduced) ? (MemberAccessExpressionSyntax)expression : null;
if (!CheckParameter(
parameter,
(isReduced) ? memberAccessExpression.Expression : arguments[0].Expression,
parameterSymbols[0]))
{
return;
}
methodSymbol = (isReduced) ? methodSymbol.GetConstructedReducedFrom() : methodSymbol;
if (!CheckInvokeMethod(lambda, methodSymbol, semanticModel, context.CancellationToken))
{
return;
}
if (!CheckSpeculativeSymbol(
lambda,
(isReduced) ? memberAccessExpression.Name.WithoutTrivia() : expression,
methodSymbol,
semanticModel,
cancellationToken))
{
return;
}
context.ReportDiagnostic(DiagnosticDescriptors.UseMethodGroupInsteadOfAnonymousFunction, lambda);
FadeOut(context, parameter, null, lambda.Body as BlockSyntax, argumentList, lambda.ArrowToken, memberAccessExpression);
}
public ParameterSymbol GetDeclaredSymbol(ParameterSyntax syntax)
{
var result = _bindingResult.GetBoundNode(syntax.Declarator) as BoundVariableDeclaration;
return result?.VariableSymbol as ParameterSymbol;
}
public override void VisitParameter(ParameterSyntax node)
{
throw new NotImplementedException();
}
protected ParameterSymbol GetSymbol(ParameterSyntax syntax)
{
return GetSymbol(syntax, models);
}
public override SyntaxNode VisitParameter(ParameterSyntax node)
{
return(node);
}
private static bool IsByteStarInParameter(ParameterSyntax parameter)
{
return(IsByteStar(parameter.Type) && !parameter.Modifiers.Any(m => m.IsKind(SyntaxKind.OutKeyword) || m.IsKind(SyntaxKind.RefKeyword)));
}
public static AttributeSyntax GetAttribute <TAttribute>(this ParameterSyntax parameter)
{
return(GetAttribute <TAttribute>(parameter.AttributeLists));
}
protected IEnumerable <CodeAction> GetActions(Document document, SemanticModel semanticModel, SyntaxNode root, TextSpan span, ParameterSyntax node)
{
if (!node.Identifier.Span.Contains(span))
{
yield break;
}
var parameter = node;
var bodyStatement = parameter.Parent.Parent.ChildNodes().OfType <BlockSyntax>().FirstOrDefault();
if (bodyStatement == null)
{
yield break;
}
var parameterSymbol = semanticModel.GetDeclaredSymbol(node);
var type = parameterSymbol.Type;
if (type.SpecialType != SpecialType.System_String || HasReturnContract(bodyStatement, parameterSymbol.Name))
{
yield break;
}
yield return(CreateAction(
node.Identifier.Span
, t2 => {
var newBody = bodyStatement.WithStatements(SyntaxFactory.List <StatementSyntax>(new[] { CreateContractRequiresCall(node.Identifier.ToString()) }.Concat(bodyStatement.Statements)));
var newRoot = (CompilationUnitSyntax)root.ReplaceNode((SyntaxNode)bodyStatement, newBody);
if (UsingStatementNotPresent(newRoot))
{
newRoot = AddUsingStatement(node, newRoot);
}
return Task.FromResult(document.WithSyntaxRoot(newRoot));
}
, "Add contract requiring parameter must not be null or empty"
));
}
public IntroduceAndInitializePropertyInfo(ParameterSyntax parameter, bool supportsCSharp6)
: base(parameter)
{
SupportsCSharp6 = supportsCSharp6;
}
private static void AnalyzeClassDeclaration(SyntaxNodeAnalysisContext context)
{
var classDeclaration = (ClassDeclarationSyntax)context.Node;
if (!classDeclaration.Identifier.ValueText.EndsWith("Extensions", StringComparison.Ordinal))
{
return;
}
if (!classDeclaration.Modifiers.Contains(SyntaxKind.StaticKeyword))
{
return;
}
if (!classDeclaration.IsParentKind(SyntaxKind.NamespaceDeclaration, SyntaxKind.CompilationUnit))
{
return;
}
if (!SyntaxAccessibility <ClassDeclarationSyntax> .Instance.GetAccessibility(classDeclaration).Is(Accessibility.Public, Accessibility.Internal))
{
return;
}
foreach (MemberDeclarationSyntax member in classDeclaration.Members)
{
if (!(member is MethodDeclarationSyntax methodDeclaration))
{
continue;
}
if (!methodDeclaration.Modifiers.Contains(SyntaxKind.StaticKeyword))
{
continue;
}
if (!SyntaxAccessibility <MethodDeclarationSyntax> .Instance.GetAccessibility(methodDeclaration).Is(Accessibility.Public, Accessibility.Internal))
{
continue;
}
ParameterSyntax parameter = methodDeclaration.ParameterList?.Parameters.FirstOrDefault();
if (parameter == null)
{
continue;
}
if (parameter.Default != null)
{
continue;
}
if (parameter.Type.IsKind(SyntaxKind.PointerType))
{
continue;
}
if (parameter.Modifiers.Contains(SyntaxKind.ParamsKeyword))
{
continue;
}
bool isThis = false;
bool isIn = false;
bool isRef = false;
foreach (SyntaxToken modifier in parameter.Modifiers)
{
SyntaxKind kind = modifier.Kind();
if (kind == SyntaxKind.ThisKeyword)
{
isThis = true;
break;
}
else if (kind == SyntaxKind.InKeyword)
{
isIn = true;
}
else if (kind == SyntaxKind.RefKeyword)
{
isRef = true;
}
if (isThis)
{
break;
}
}
if (isThis)
{
continue;
}
if (isIn)
{
IParameterSymbol parameterSymbol = context.SemanticModel.GetDeclaredSymbol(parameter, context.CancellationToken);
ITypeSymbol typeSymbol = parameterSymbol.Type;
if (!typeSymbol.IsValueType)
{
continue;
}
if (typeSymbol.Kind == SymbolKind.TypeParameter)
{
continue;
}
}
else if (isRef)
{
IParameterSymbol parameterSymbol = context.SemanticModel.GetDeclaredSymbol(parameter, context.CancellationToken);
if (!parameterSymbol.Type.IsValueType)
{
continue;
}
}
DiagnosticHelpers.ReportDiagnostic(context, DiagnosticDescriptors.MakeMethodExtensionMethod, methodDeclaration.Identifier);
}
}
public static SourceParameterSymbol Create(
Binder context,
Symbol owner,
TypeSymbol parameterType,
ParameterSyntax syntax,
RefKind refKind,
SyntaxToken identifier,
int ordinal,
bool isParams,
bool isExtensionMethodThis,
DiagnosticBag diagnostics,
bool beStrict)
{
var name = identifier.ValueText;
var locations = ImmutableArray.Create <Location>(new SourceLocation(identifier));
if (isParams)
{
// touch the constructor in order to generate proper use-site diagnostics
Binder.ReportUseSiteDiagnosticForSynthesizedAttribute(context.Compilation,
WellKnownMember.System_ParamArrayAttribute__ctor,
diagnostics,
identifier.Parent.GetLocation());
}
if (!isParams &&
!isExtensionMethodThis &&
(syntax.Default == null) &&
(syntax.AttributeLists.Count == 0) &&
!owner.IsPartialMethod())
{
return(new SourceSimpleParameterSymbol(owner, parameterType, ordinal, refKind, name, locations));
}
if (beStrict)
{
return(new SourceStrictComplexParameterSymbol(
diagnostics,
context,
owner,
ordinal,
parameterType,
refKind,
false,
name,
locations,
syntax.GetReference(),
ConstantValue.Unset,
isParams,
isExtensionMethodThis));
}
return(new SourceComplexParameterSymbol(
owner,
ordinal,
parameterType,
refKind,
name,
locations,
syntax.GetReference(),
ConstantValue.Unset,
isParams,
isExtensionMethodThis));
}
public async Task <Document> IntroduceFieldFromConstructorDocumentAsync(Document document, ConstructorDeclarationSyntax constructorStatement, ParameterSyntax parameter, CancellationToken cancellationToken)
{
var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var newRoot = IntroduceFieldFromConstructor(root, constructorStatement, parameter);
var newDocument = document.WithSyntaxRoot(newRoot);
return(document.WithSyntaxRoot(newRoot));
}
public override SyntaxNode?VisitParameter(ParameterSyntax node)
{
AddMappedIdentifier(node.Identifier);
return(base.VisitParameter(node.WithIdentifier(MappedIdentifier(node.Identifier))));
}
private static string GetType(ParameterSyntax x)
{
return(x.Type.ToString());
}
public override void VisitParameter(ParameterSyntax node)
{
this.Found |= node.Identifier.ValueText == this.name;
base.VisitParameter(node);
}
void CompileFragmentParameter(ParameterSyntax parameter, bool specialized)
{
var info = GetModel(parameter).GetSymbolInfo(parameter.Type);
var symbol = info.Symbol as TypeSymbol;
if (symbol != null)
{
var translation_info = TranslationLookup.RecursiveLookup(symbol);
if (translation_info.Translation != null)
{
if (translation_info.Translation == "sampler")
{
CompileSamplerParameter(parameter, symbol);
}
else
{
string type = translation_info.Translation;
string name = parameter.Identifier.ValueText;
string mapped_name = FragmentShaderParameterPrefix + name;
if (!specialized)
{
Write(type);
Write(" ");
Write(mapped_name);
Write(";");
}
var param = new Param(parameter.Type.ToString(), type, name, mapped_name, Param.ParamType.FragmentParam);
if (!specialized) Params.Add(param);
AllParams.Add(param);
}
}
}
}
public static SourceParameterSymbol Create(
Binder context,
Symbol owner,
TypeSymbol parameterType,
ParameterSyntax syntax,
RefKind refKind,
SyntaxToken identifier,
int ordinal,
bool isParams,
bool isExtensionMethodThis,
bool addRefReadOnlyModifier,
DiagnosticBag declarationDiagnostics)
{
var name = identifier.ValueText;
var locations = ImmutableArray.Create <Location>(new SourceLocation(identifier));
if (isParams)
{
// touch the constructor in order to generate proper use-site diagnostics
Binder.ReportUseSiteDiagnosticForSynthesizedAttribute(context.Compilation,
WellKnownMember.System_ParamArrayAttribute__ctor,
declarationDiagnostics,
identifier.Parent.GetLocation());
}
if (addRefReadOnlyModifier && refKind == RefKind.In)
{
var modifierType = context.GetWellKnownType(WellKnownType.System_Runtime_InteropServices_InAttribute, declarationDiagnostics, syntax);
return(new SourceComplexParameterSymbolWithCustomModifiers(
owner,
ordinal,
parameterType,
refKind,
ImmutableArray <CustomModifier> .Empty,
ImmutableArray.Create(CSharpCustomModifier.CreateRequired(modifierType)),
name,
locations,
syntax.GetReference(),
ConstantValue.Unset,
isParams,
isExtensionMethodThis));
}
if (!isParams &&
!isExtensionMethodThis &&
(syntax.Default == null) &&
(syntax.AttributeLists.Count == 0) &&
!owner.IsPartialMethod())
{
return(new SourceSimpleParameterSymbol(owner, parameterType, ordinal, refKind, name, locations));
}
return(new SourceComplexParameterSymbol(
owner,
ordinal,
parameterType,
refKind,
name,
locations,
syntax.GetReference(),
ConstantValue.Unset,
isParams,
isExtensionMethodThis));
}
void CompileVertexParameter(ParameterSyntax parameter)
{
var info = GetModel(parameter).GetSymbolInfo(parameter.Type);
var symbol = info.Symbol as TypeSymbol;
if (symbol != null)
{
var translation_info = TranslationLookup.RecursiveLookup(symbol);
if (translation_info.Translation != null)
{
if (translation_info.Translation == "sampler")
{
Write("ERROR(Samplers not suported in vertex shaders : {0})", parameter);
}
else
{
string type = translation_info.Translation;
string name = parameter.Identifier.ValueText;
string mapped_name = VertexShaderParameterPrefix + name;
Write(type);
Write(" ");
Write(mapped_name);
Write(";");
var param = new Param(parameter.Type.ToString(), type, name, mapped_name, Param.ParamType.VertexParam);
Params.Add(param);
AllParams.Add(param);
}
}
}
}
public IntroduceAndInitializeFieldInfo(ParameterSyntax parameter, bool prefixFieldIndentifierWithUnderscore = false)
: base(parameter)
{
PrefixFieldIdentifierWithUnderscore = prefixFieldIndentifierWithUnderscore;
}
protected abstract XmlElementSyntax Comment(Document document, XmlElementSyntax comment, ParameterSyntax parameter, int index);
private bool CompareModifiers(ParameterSyntax oldParameter, ParameterSyntax newParameter) => oldParameter.GetParameterFlags() == newParameter.GetParameterFlags();
/// <summary>
/// Report diagnostic for marshalling of a parameter/return that is not supported
/// </summary>
/// <param name="method">Method with the parameter/return</param>
/// <param name="info">Type info for the parameter/return</param>
/// <param name="notSupportedDetails">[Optional] Specific reason for lack of support</param>
public void ReportMarshallingNotSupported(
MethodDeclarationSyntax method,
TypePositionInfo info,
string?notSupportedDetails,
ImmutableDictionary <string, string> diagnosticProperties)
{
Location diagnosticLocation = Location.None;
string elementName = string.Empty;
if (info.IsManagedReturnPosition)
{
diagnosticLocation = Location.Create(method.SyntaxTree, method.Identifier.Span);
elementName = method.Identifier.ValueText;
}
else
{
Debug.Assert(info.ManagedIndex <= method.ParameterList.Parameters.Count);
ParameterSyntax param = method.ParameterList.Parameters[info.ManagedIndex];
diagnosticLocation = Location.Create(param.SyntaxTree, param.Identifier.Span);
elementName = param.Identifier.ValueText;
}
if (!string.IsNullOrEmpty(notSupportedDetails))
{
// Report the specific not-supported reason.
if (info.IsManagedReturnPosition)
{
_diagnostics.Add(
diagnosticLocation.CreateDiagnostic(
GeneratorDiagnostics.ReturnTypeNotSupportedWithDetails,
diagnosticProperties,
notSupportedDetails !,
elementName));
}
else
{
_diagnostics.Add(
diagnosticLocation.CreateDiagnostic(
GeneratorDiagnostics.ParameterTypeNotSupportedWithDetails,
diagnosticProperties,
notSupportedDetails !,
elementName));
}
}
else if (info.MarshallingAttributeInfo is MarshalAsInfo)
{
// Report that the specified marshalling configuration is not supported.
// We don't forward marshalling attributes, so this is reported differently
// than when there is no attribute and the type itself is not supported.
if (info.IsManagedReturnPosition)
{
_diagnostics.Add(
diagnosticLocation.CreateDiagnostic(
GeneratorDiagnostics.ReturnConfigurationNotSupported,
diagnosticProperties,
nameof(System.Runtime.InteropServices.MarshalAsAttribute),
elementName));
}
else
{
_diagnostics.Add(
diagnosticLocation.CreateDiagnostic(
GeneratorDiagnostics.ParameterConfigurationNotSupported,
diagnosticProperties,
nameof(System.Runtime.InteropServices.MarshalAsAttribute),
elementName));
}
}
else
{
// Report that the type is not supported
if (info.IsManagedReturnPosition)
{
_diagnostics.Add(
diagnosticLocation.CreateDiagnostic(
GeneratorDiagnostics.ReturnTypeNotSupported,
diagnosticProperties,
info.ManagedType.DiagnosticFormattedName,
elementName));
}
else
{
_diagnostics.Add(
diagnosticLocation.CreateDiagnostic(
GeneratorDiagnostics.ParameterTypeNotSupported,
diagnosticProperties,
info.ManagedType.DiagnosticFormattedName,
elementName));
}
}
}
public static Task <Document> RefactorAsync(
Document document,
SyntaxNode methodOrLocalFunction,
LocalDeclarationStatementSyntax localDeclaration,
TypeSyntax type,
VariableDeclaratorSyntax variable,
CancellationToken cancellationToken = default)
{
int variableCount = localDeclaration.Declaration.Variables.Count;
ExpressionSyntax initializerValue = variable.Initializer?.Value;
SyntaxToken identifier = variable.Identifier.WithoutTrivia();
SyntaxNode newNode = methodOrLocalFunction;
if (initializerValue != null)
{
ExpressionStatementSyntax expressionStatement = SimpleAssignmentStatement(
IdentifierName(identifier),
initializerValue);
expressionStatement = expressionStatement.WithFormatterAnnotation();
if (variableCount > 1)
{
LocalDeclarationStatementSyntax newLocalDeclaration = localDeclaration.RemoveNode(
variable,
SyntaxRemoveOptions.KeepUnbalancedDirectives);
newNode = newNode.ReplaceNode(
localDeclaration,
new SyntaxNode[] { newLocalDeclaration, expressionStatement });
}
else
{
newNode = newNode.ReplaceNode(
localDeclaration,
expressionStatement.WithTriviaFrom(localDeclaration));
}
}
else if (variableCount > 1)
{
newNode = newNode.RemoveNode(variable, SyntaxRemoveOptions.KeepUnbalancedDirectives);
}
else
{
newNode = newNode.RemoveNode(localDeclaration, SyntaxRemoveOptions.KeepUnbalancedDirectives);
}
ParameterSyntax newParameter = Parameter(type, identifier).WithFormatterAnnotation();
if (newNode is MethodDeclarationSyntax methodDeclaration)
{
newNode = methodDeclaration.AddParameterListParameters(newParameter);
}
else
{
var localFunction = (LocalFunctionStatementSyntax)newNode;
newNode = localFunction.AddParameterListParameters(newParameter);
}
return(document.ReplaceNodeAsync(methodOrLocalFunction, newNode, cancellationToken));
}
public void SetParameter(SyntaxNode node)
{
parameter = (ParameterSyntax) node;
}
public override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
var diagnostic = context.Diagnostics.FirstOrDefault(d => d.Id == Id);
if (diagnostic == null)
{
return;
}
var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
var diagnosticSpan = diagnostic.Location.SourceSpan;
// Find the name/paramName argument identified by the diagnostic.
var nameArg = root.FindToken(diagnosticSpan.Start).Parent.FirstAncestorOrSelf <ArgumentSyntax>();
string nameArgValue = (nameArg.Expression as LiteralExpressionSyntax)?.Token.ValueText;
// If not a string literal, or not a valid identifier, there really is very little we can do. Suggest nothing.
if (nameArgValue == null || !SyntaxFacts.IsValidIdentifier(nameArgValue))
{
return;
}
Debug.Assert(nameArg.Parent.Parent.IsKind(SyntaxKind.InvocationExpression));
var invokeExp = (InvocationExpressionSyntax)nameArg.Parent.Parent;
var member = invokeExp.Expression as MemberAccessExpressionSyntax;
var methodName = member.ToString(); // Something like CheckParam, ExceptUserArg...
// Check whether this is a simple case, that is, this string has the same text as some token.
var argList = (ArgumentListSyntax)nameArg.Parent;
// One of the most common checks are checks for value. Check whether this is the case.
// If it is, we don't even have to resort to extracting the semantic model.
argList.Arguments[0].Expression.GetText();
if (nameArg.NameColon == null && argList.Arguments.Count >= 2 &&
argList.Arguments[1] == nameArg && argList.Arguments[0].Expression.ToString() == nameArgValue)
{
context.RegisterCodeFix(CodeAction.Create(Title,
c => StringReplace(context.Document, nameArgValue, nameArg, c), Id), diagnostic);
return;
}
// Check all symbols used in the Check/Except argument. Let's see if there's a match.
// In the event of ambiguity, we choose the shortest one, figuring that the least complex
// might be the most likely.
int shortestSymbol = int.MaxValue;
ExpressionSyntax bestSymbol = null;
var sameNameNodes = argList.DescendantTokens().Where(tok => tok.Text == nameArgValue)
.Select(p => p.Parent).Where(n => n.IsKind(SyntaxKind.IdentifierName));
foreach (var node in sameNameNodes)
{
SyntaxNode candidate = node;
var pk = node.Parent.Kind();
if (pk == SyntaxKind.SimpleMemberAccessExpression)
{
var parentAccess = (MemberAccessExpressionSyntax)node.Parent;
candidate = parentAccess.Expression == node ? node : parentAccess;
}
else if (pk == SyntaxKind.QualifiedName)
{
// A little weird, but if you have class Z nested in Y, nested in X, then typeof(X.Y.Z) will
// be a series of qualified names, but nameof(X.Y.Z) will be a series of simple member accesses.
// nameof(X.Y.Z) if phrased as qualified names will not work.
candidate = SyntaxFactory.ParseExpression(node.Parent.ToString());
}
if (candidate.Span.Length < shortestSymbol)
{
bestSymbol = (ExpressionSyntax)candidate;
shortestSymbol = candidate.Span.Length;
}
}
if (bestSymbol != null)
{
context.RegisterCodeFix(CodeAction.Create(Title,
c => ExpressionReplace(context.Document, bestSymbol, nameArg, c), Id), diagnostic);
return;
}
// No luck within the check statement itself. Next check the parameter list of this method or constructor.
SyntaxNode temp = nameArg;
while (temp != null && !temp.IsKind(SyntaxKind.MethodDeclaration) && !temp.IsKind(SyntaxKind.ConstructorDeclaration))
{
temp = temp.Parent;
}
ParameterSyntax argParam = null;
if (temp != null)
{
var paramList = (temp as MethodDeclarationSyntax)?.ParameterList
?? ((ConstructorDeclarationSyntax)temp).ParameterList;
foreach (var param in paramList.Parameters)
{
if (param.Identifier.ToString() == nameArgValue)
{
context.RegisterCodeFix(CodeAction.Create(Title,
c => StringReplace(context.Document, nameArgValue, nameArg, c), Id), diagnostic);
return;
}
// A hack, but whatever works.
string paramTypeString = param.Type.ToString();
if (argParam == null && (paramTypeString == "Arguments" || paramTypeString == "Column"))
{
argParam = param;
}
}
}
// All else has failed. The last is to try to get information from any Arguments object, if present.
if (argParam != null)
{
var semanticModel = await context.Document.GetSemanticModelAsync(context.CancellationToken);
var type = semanticModel.GetTypeInfo(argParam.Type, context.CancellationToken).Type;
var argName = argParam.Identifier.ToString();
if (type != null && !(type is IErrorTypeSymbol))
{
//var m = type.GetMembers().Cast<IFieldSymbol>;
foreach (IFieldSymbol s in type.GetMembers().Where(p => p.Kind == SymbolKind.Field))
{
if (!s.CanBeReferencedByName)
{
continue;
}
AttributeData attr = s.GetAttributes().FirstOrDefault(a => a.AttributeClass.Name == "ArgumentAttribute");
if (attr == null)
{
continue;
}
if (s.Name == nameArgValue)
{
context.RegisterCodeFix(CodeAction.Create(Title,
c => StringReplace(context.Document, argName + "." + s.Name, nameArg, c), Id), diagnostic);
return;
}
var shortPair = attr.NamedArguments.FirstOrDefault(p => p.Key == "ShortName");
var shortName = shortPair.Value.Value as string;
if (shortName == null)
{
continue;
}
if (shortName.Split(',').Contains(nameArgValue))
{
context.RegisterCodeFix(CodeAction.Create(Title,
c => StringReplace(context.Document, argName + "." + s.Name, nameArg, c), Id), diagnostic);
return;
}
}
}
}
}
public SourceParameterSymbol(ParameterSyntax syntax, Symbol parent, TypeSymbol valueType, ParameterDirection direction = ParameterDirection.In)
: base(syntax.Declarator.Identifier.Text, string.Empty, parent, valueType, direction)
{
Syntax = syntax;
}
public IntroduceAndInitializeInfo(ParameterSyntax parameter)
{
Parameter = parameter;
ParameterName = parameter.Identifier.ValueText;
}
public virtual void PostWalkParameter(ParameterSyntax parameterSyntax) { }
protected abstract void CompileMethodParameter(ParameterSyntax parameter);
