private static bool ShouldUseOverrideKeyword(MemberDeclarationSyntax member, bool isInterface)
{
ISymbol symbol = TypeProcessor.GetDeclaredSymbol(member);
if (symbol is IMethodSymbol)
{
if ((symbol as IMethodSymbol).IsGenericMethod)
return false;
}
if (symbol.ContainingType.TypeKind == TypeKind.Struct ||
symbol.ContainingType.TypeKind == TypeKind.Interface)
{
return false;
// Structs dont have a base class to override (maybe opEquals) ... but that will be handled separately
//Interfaces are contracts, so no overriding here// maybe we should compare the methods
}
if (member.GetModifiers().Any(SyntaxKind.OverrideKeyword) && !isInterface)
return true;
if (member.GetModifiers().Any(SyntaxKind.StaticKeyword))
return false;
// if (method.Modifiers.Any(SyntaxKind.NewKeyword))
// return symbol.ContainingType.BaseType.GetMembers(symbol.Name).Any(k=>k.IsAbstract || k.IsVirtual);
if (member.GetModifiers().Any(SyntaxKind.PartialKeyword))
//partial methods seem exempt from C#'s normal override keyword requirement, so we have to check manually to see if it exists in a base class
return symbol.ContainingType.BaseType.GetMembers(symbol.Name).Any();
return member.GetModifiers().Any(SyntaxKind.OverrideKeyword);
}
public static ClassDeclarationSyntax Create(string name, BaseTypeSyntax[] baseTypes, ConstructorDeclarationSyntax constructor, MemberDeclarationSyntax[] body)
{
return SyntaxFactory.ClassDeclaration(name)
.AddBaseListTypes(baseTypes)
.AddMembers(constructor)
.AddMembers(body);
}
private Accessibility GetDeclaredAccessibility(MemberDeclarationSyntax declaration)
{
var result = Accessibility.Private;
SyntaxTokenList? syntaxTokenList;
syntaxTokenList = (declaration as PropertyDeclarationSyntax)?.Modifiers ??
(declaration as FieldDeclarationSyntax)?.Modifiers ??
(declaration as ConstructorDeclarationSyntax)?.Modifiers ??
(declaration as MethodDeclarationSyntax)?.Modifiers;
var accessibilityToken = syntaxTokenList?.Where(x => accessibilityTypes.Contains(x.Kind())).FirstOrDefault();
if (accessibilityToken.HasValue)
{
switch (accessibilityToken.Value.Kind())
{
case SyntaxKind.PublicKeyword:
result = Accessibility.Public;
break;
case SyntaxKind.PrivateKeyword:
result = Accessibility.Private;
break;
case SyntaxKind.InternalKeyword:
result = Accessibility.Internal;
break;
case SyntaxKind.ProtectedKeyword:
result = Accessibility.Protected;
break;
default:
result = Accessibility.Private;
break;
}
}
return result;
}
/// <inheritdoc />
public Task<SyntaxList<MemberDeclarationSyntax>> GenerateAsync(MemberDeclarationSyntax applyTo, Document document, IProgress<Diagnostic> progress, CancellationToken cancellationToken)
{
var type = (ClassDeclarationSyntax)applyTo;
var generatedType = type
.WithMembers(SyntaxFactory.List<MemberDeclarationSyntax>());
var methodsWithNativePointers =
from method in type.Members.OfType<MethodDeclarationSyntax>()
where WhereIsPointerParameter(method.ParameterList.Parameters).Any() || method.ReturnType is PointerTypeSyntax
select method;
foreach (var method in methodsWithNativePointers)
{
var intPtrOverload = method
.WithParameterList(TransformParameterList(method.ParameterList))
.WithReturnType(TransformReturnType(method.ReturnType))
.WithIdentifier(TransformMethodName(method))
.WithModifiers(RemoveModifier(method.Modifiers, SyntaxKind.ExternKeyword))
.WithAttributeLists(SyntaxFactory.List<AttributeListSyntax>())
.WithLeadingTrivia(method.GetLeadingTrivia().Where(t => !t.IsDirective))
.WithTrailingTrivia(method.GetTrailingTrivia().Where(t => !t.IsDirective))
.WithBody(CallNativePointerOverload(method))
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.None));
generatedType = generatedType.AddMembers(intPtrOverload);
}
return Task.FromResult(SyntaxFactory.SingletonList<MemberDeclarationSyntax>(generatedType));
}
private static void CheckDeclarationName(MemberDeclarationSyntax member, SyntaxToken identifier, SyntaxNodeAnalysisContext context)
{
var symbol = context.SemanticModel.GetDeclaredSymbol(member);
if (ClassName.IsTypeComRelated(symbol?.ContainingType) ||
symbol.IsInterfaceImplementationOrMemberOverride() ||
symbol.IsExtern)
{
return;
}
if (identifier.ValueText.StartsWith("_", StringComparison.Ordinal) ||
identifier.ValueText.EndsWith("_", StringComparison.Ordinal))
{
context.ReportDiagnostic(Diagnostic.Create(Rule, identifier.GetLocation(), MethodKindNameMapping[member.Kind()],
identifier.ValueText, MessageFormatUnderscore));
return;
}
string suggestion;
if (TryGetChangedName(identifier.ValueText, out suggestion))
{
var messageEnding = string.Format(MessageFormatNonUnderscore, suggestion);
context.ReportDiagnostic(Diagnostic.Create(Rule, identifier.GetLocation(), MethodKindNameMapping[member.Kind()],
identifier.ValueText, messageEnding));
}
}
public YieldClassGenerator(Compilation compilation, ClassDeclarationSyntax classDeclarationSyntax, MemberDeclarationSyntax node)
{
this.compilation = compilation;
this.classDeclarationSyntax = classDeclarationSyntax;
this.node = node;
method = ModelExtensions.GetDeclaredSymbol(compilation.GetSemanticModel(node.SyntaxTree), node);
}
/// <summary>
/// Initializes a new instance of the <see cref="MemberOrderHelper"/> struct.
/// </summary>
/// <param name="member">The member to wrap.</param>
public MemberOrderHelper(MemberDeclarationSyntax member)
{
this.Member = member;
var modifiers = member.GetModifiers();
this.modifierFlags = GetModifierFlags(modifiers);
this.accessibilty = AccessLevelHelper.GetAccessLevel(modifiers);
}
public static bool HasYield(MemberDeclarationSyntax method)
{
if (method.IsAsync())
return false;
var yieldChecker = new YieldChecker(true);
method.Accept(yieldChecker);
return yieldChecker.isSpecial;
}
private SyntaxNode VisitMemberDeclaration(MemberDeclarationSyntax node, SyntaxNode newNode)
{
var newMember = ((MemberDeclarationSyntax) newNode).WithoutAttributes();
var isSolutionPart = node.HasAttribute<ExcludeFromSolutionAttribute>() || node.HasAttribute<ExerciseAttribute>();
if (node.HasAttribute<ExcludeFromSolutionAttribute>()
|| (node is TypeDeclarationSyntax && node.HasAttribute<ExerciseAttribute>()))
Exercise.EthalonSolution += newMember.ToFullString();
return isSolutionPart ? null : newMember;
}
internal static int Sort(MemberDeclarationSyntax first, MemberDeclarationSyntax second)
{
Requires.NotNull(first, "first");
Requires.NotNull(second, "second");
int firstOrder = GetMemberDeclarationTypeOrder(first);
int secondOrder = GetMemberDeclarationTypeOrder(second);
int compareResult = firstOrder.CompareTo(secondOrder);
if (compareResult == 0)
{
firstOrder = GetMemberDeclarationVisibilityOrder(first);
secondOrder = GetMemberDeclarationVisibilityOrder(second);
compareResult = firstOrder.CompareTo(secondOrder);
if (compareResult == 0)
{
bool firstIsStatic = first.HasModifier(SyntaxKind.StaticKeyword);
bool secondIsStatic = second.HasModifier(SyntaxKind.StaticKeyword);
if (firstIsStatic && !secondIsStatic)
{
compareResult = -1;
}
else if (!firstIsStatic && secondIsStatic)
{
compareResult = 1;
}
if (compareResult == 0)
{
bool firstIsReadOnly = first.HasModifier(SyntaxKind.ReadOnlyKeyword);
bool secondIsReadOnly = second.HasModifier(SyntaxKind.ReadOnlyKeyword);
if (firstIsReadOnly && !secondIsReadOnly)
{
compareResult = -1;
}
else if (!firstIsReadOnly && secondIsReadOnly)
{
compareResult = 1;
}
if (compareResult == 0)
{
var firstName = GetName(first);
var secondName = GetName(second);
if (firstName.HasValue && secondName.HasValue)
{
compareResult = string.Compare(firstName.Value.ValueText, secondName.Value.ValueText, StringComparison.CurrentCulture);
}
}
}
}
}
return compareResult;
}
/// <summary>
/// Initializes a new instance of the <see cref="MemberOrderHelper"/> struct.
/// </summary>
/// <param name="member">The member to wrap.</param>
/// <param name="elementOrder">The element ordering traits.</param>
internal MemberOrderHelper(MemberDeclarationSyntax member, ImmutableArray<OrderingTrait> elementOrder)
{
this.Member = member;
var modifiers = member.GetModifiers();
var type = member.Kind();
type = type == SyntaxKind.EventFieldDeclaration ? SyntaxKind.EventDeclaration : type;
this.Priority = 0;
foreach (OrderingTrait trait in elementOrder)
{
switch (trait)
{
case OrderingTrait.Kind:
// 4 bits are required to store this.
this.Priority <<= 4;
this.Priority |= TypeMemberOrder.IndexOf(type) & 0x0F;
break;
case OrderingTrait.Accessibility:
// 3 bits are required to store this.
this.Priority <<= 3;
this.Priority |= (int)GetAccessLevelForOrdering(member, modifiers) & 0x07;
break;
case OrderingTrait.Constant:
this.Priority <<= 1;
if (modifiers.Any(SyntaxKind.ConstKeyword))
{
this.Priority |= 1;
}
break;
case OrderingTrait.Static:
this.Priority <<= 1;
if (modifiers.Any(SyntaxKind.StaticKeyword))
{
this.Priority |= 1;
}
break;
case OrderingTrait.Readonly:
this.Priority <<= 1;
if (modifiers.Any(SyntaxKind.ReadOnlyKeyword))
{
this.Priority |= 1;
}
break;
default:
continue;
}
}
}
private SyntaxNode VisitMemberDeclaration(MemberDeclarationSyntax node, SyntaxNode newNode)
{
var parent = node.GetParents().OfType<BaseTypeDeclarationSyntax>().FirstOrDefault();
if (!ShowOnSlide(node)) return null;
if (parent == null
|| parent.HasAttribute<SlideAttribute>()
|| parent.HasAttribute<ShowBodyOnSlideAttribute>())
AddCodeBlock(((MemberDeclarationSyntax)newNode));
return ((MemberDeclarationSyntax)newNode).WithoutAttributes();
}
internal static IEnumerable<ISymbol> GetDeclaredSymbols(SemanticModel semanticModel, MemberDeclarationSyntax memberDeclaration, CancellationToken cancellationToken)
{
if (memberDeclaration is FieldDeclarationSyntax)
{
return ((FieldDeclarationSyntax)memberDeclaration).Declaration.Variables.Select(
v => semanticModel.GetDeclaredSymbol(v, cancellationToken));
}
return SpecializedCollections.SingletonEnumerable(
semanticModel.GetDeclaredSymbol(memberDeclaration, cancellationToken));
}
public static MemberDeclarationSyntax UpdateNamedTypeDeclaration(
ICodeGenerationService service,
MemberDeclarationSyntax declaration,
IList<ISymbol> newMembers,
CodeGenerationOptions options,
CancellationToken cancellationToken)
{
declaration = RemoveAllMembers(declaration);
declaration = service.AddMembers(declaration, newMembers, options, cancellationToken);
return AddCleanupAnnotationsTo(declaration);
}
protected SyntaxNode HoistVariable(CSharpSyntaxNode node, SyntaxToken identifier, TypeSyntax type)
{
if (hoistedVariables.ContainsKey(identifier.ToString()))
{
var newName = GenerateNewName(identifier);
var newIdentifier = SyntaxFactory.Identifier(newName);
node = IdentifierRenamer.RenameIdentifier(node, identifier, newIdentifier);
identifier = newIdentifier;
}
hoistedVariables[identifier.ToString()] = type;
return node;
}
private async Task<Document> ExtractToExpressionTree(Document document, MemberDeclarationSyntax declaration, CancellationToken c)
{
var typeSyntax = declaration.Ancestors().OfType<TypeDeclarationSyntax>().First();
var sm = await document.GetSemanticModelAsync(c);
var type = sm.GetDeclaredSymbol(typeSyntax, c);
var symbol = sm.GetDeclaredSymbol(declaration);
string name = declaration is MethodDeclarationSyntax ?
((MethodDeclarationSyntax)declaration).Identifier.ToString() :
((PropertyDeclarationSyntax)declaration).Identifier.ToString();
string candidateName = name + "Expression";
if (type.MemberNames.Contains(candidateName))
candidateName = Enumerable.Range(2, 1000).Select(i => name + "Expression" + i).First(n => !type.MemberNames.Contains(n));
List<ParameterSyntax> parameterList = GetParameters(declaration, type, symbol);
TypeSyntax returnType = GetReturnType(declaration);
var bodyExpression = GetSingleBody(declaration);
var newField = GetStaticField(candidateName, parameterList, returnType, bodyExpression, sm, type);
var newBody = GetNewBody(candidateName, parameterList);
var newDeclaration = declaration.ReplaceNode(bodyExpression, newBody);
MoveInitialTrivia(ref newField, ref newDeclaration);
var newMembers = typeSyntax.Members.ReplaceRange(declaration, new[] { newField, newDeclaration });
var newType = typeSyntax is StructDeclarationSyntax ?
(TypeDeclarationSyntax)((StructDeclarationSyntax)typeSyntax).WithMembers(newMembers) :
(TypeDeclarationSyntax)((ClassDeclarationSyntax)typeSyntax).WithMembers(newMembers);
var docRoot = await document.GetSyntaxRootAsync();
var newDoc = docRoot.ReplaceNode(typeSyntax, newType);
var usings = newDoc.ChildNodes().OfType<UsingDirectiveSyntax>();
if (usings.Any() && !usings.Any(a => a.Name.ToString() == "System.Linq.Expressions"))
newDoc = newDoc.InsertNodesAfter(usings.LastOrDefault(), new[] {
SyntaxFactory.UsingDirective(
SyntaxFactory.IdentifierName("System").Qualified("Linq").Qualified("Expressions")
).NormalizeWhitespace().WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed)
});
return document.WithSyntaxRoot(newDoc);
}
/// <inheritdoc />
public Task<SyntaxList<MemberDeclarationSyntax>> GenerateAsync(MemberDeclarationSyntax applyTo, Document document, IProgress<Diagnostic> progress, CancellationToken cancellationToken)
{
var applyToStruct = applyTo as StructDeclarationSyntax;
var applyToClass = applyTo as ClassDeclarationSyntax;
var applyToType = applyTo as TypeDeclarationSyntax;
var generatedMembers = SyntaxFactory.List<MemberDeclarationSyntax>();
var nativePointerFields = from field in applyToType.Members.OfType<FieldDeclarationSyntax>()
where field.Declaration.Type is PointerTypeSyntax && field.Modifiers.Any(m => m.IsKind(SyntaxKind.PublicKeyword))
select field;
foreach (var field in nativePointerFields)
{
foreach (var variable in field.Declaration.Variables)
{
generatedMembers = generatedMembers.Add(
SyntaxFactory.PropertyDeclaration(IntPtrTypeSyntax, variable.Identifier.ValueText + "_IntPtr")
.WithModifiers(field.Modifiers)
//// get { return new IntPtr(this.field); }
//// set { this.field = (byte*)value.ToPointer(); }
.AddAccessorListAccessors(
SyntaxFactory.AccessorDeclaration(
SyntaxKind.GetAccessorDeclaration,
SyntaxFactory.Block(
SyntaxFactory.ReturnStatement(
SyntaxFactory.ObjectCreationExpression(IntPtrTypeSyntax)
.AddArgumentListArguments(SyntaxFactory.Argument(ThisDot(variable.Identifier)))))),
SyntaxFactory.AccessorDeclaration(
SyntaxKind.SetAccessorDeclaration,
SyntaxFactory.Block(
SyntaxFactory.ExpressionStatement(
SyntaxFactory.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
ThisDot(variable.Identifier),
TypedAs(
SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("value"),
SyntaxFactory.IdentifierName(nameof(IntPtr.ToPointer))),
SyntaxFactory.ArgumentList()),
field.Declaration.Type)))))));
}
}
var generatedType = (TypeDeclarationSyntax)applyToStruct?.WithMembers(generatedMembers)
.WithAttributeLists(SyntaxFactory.List<AttributeListSyntax>())
?? applyToClass?.WithMembers(generatedMembers)
.WithAttributeLists(SyntaxFactory.List<AttributeListSyntax>());
return Task.FromResult(SyntaxFactory.SingletonList<MemberDeclarationSyntax>(generatedType));
}
private static MemberDeclarationSyntax BeforeMember(
SyntaxList<MemberDeclarationSyntax> members,
MemberDeclarationSyntax eventDeclaration)
{
// If it's a field style event, then it goes before everything else if we don't have any
// existing fields/events.
if (eventDeclaration.Kind() == SyntaxKind.FieldDeclaration)
{
return members.FirstOrDefault();
}
// Otherwise just place it before the methods.
return FirstMethod(members);
}
private static SyntaxNode MoveField(SyntaxNode root, MemberDeclarationSyntax field, MemberDeclarationSyntax firstNonConst)
{
var trackedRoot = root.TrackNodes(field, firstNonConst);
var fieldToMove = trackedRoot.GetCurrentNode(field);
var firstNonConstTracked = trackedRoot.GetCurrentNode(firstNonConst);
if (!fieldToMove.HasLeadingTrivia)
{
fieldToMove = fieldToMove.WithLeadingTrivia(firstNonConstTracked.GetLeadingTrivia().Where(x => x.IsKind(SyntaxKind.WhitespaceTrivia)).LastOrDefault());
}
root = trackedRoot.InsertNodesBefore(firstNonConstTracked, new[] { fieldToMove });
var fieldToMoveTracked = root.GetCurrentNodes(field).Last();
return root.RemoveNode(fieldToMoveTracked, SyntaxRemoveOptions.KeepNoTrivia);
}
static bool IsObsolete (MemberDeclarationSyntax entity)
{
if (entity == null)
return false;
// TODO!
// foreach (var section in entity.Attributes) {
// foreach (var attr in section.Attributes) {
// var attrText = attr.Type.ToString ();
// if (attrText == "Obsolete" || attrText == "ObsoleteAttribute" || attrText == "System.Obsolete" || attrText == "System.ObsoleteAttribute" )
// return true;
// }
// }
return false;
}
public Task<IReadOnlyList<MemberDeclarationSyntax>> GenerateAsync(MemberDeclarationSyntax applyTo, Document document, IProgress<Diagnostic> progress, CancellationToken cancellationToken)
{
Requires.NotNull(applyTo, nameof(applyTo));
var options = new CodeGen.Options(this.attributeData)
{
GenerateBuilder = this.GetBoolData(nameof(GenerateImmutableAttribute.GenerateBuilder)),
Delta = this.GetBoolData(nameof(GenerateImmutableAttribute.Delta)),
DefineInterface = this.GetBoolData(nameof(GenerateImmutableAttribute.DefineInterface)),
DefineRootedStruct = this.GetBoolData(nameof(GenerateImmutableAttribute.DefineRootedStruct)),
DefineWithMethodsPerProperty = this.GetBoolData(nameof(GenerateImmutableAttribute.DefineWithMethodsPerProperty)),
};
return CodeGen.GenerateAsync((ClassDeclarationSyntax)applyTo, document, progress, options, cancellationToken);
}
private IEnumerable<SyntaxNode> GetAllTopLevelTypeDefined(MemberDeclarationSyntax member)
{
var namespaceMember = member as NamespaceDeclarationSyntax;
if (namespaceMember != null)
{
return namespaceMember.Members.SelectMany(GetAllTopLevelTypeDefined);
}
var type = member as ClassDeclarationSyntax;
if (type != null)
{
return SpecializedCollections.SingletonEnumerable<SyntaxNode>(type);
}
return SpecializedCollections.EmptyEnumerable<SyntaxNode>();
}
public static bool IsEvalCandidate(this SemanticModel model, MemberDeclarationSyntax member)
{
if (member.Kind() != SyntaxKind.FieldDeclaration)
return false;
var field = member as FieldDeclarationSyntax;
var attrDeclares = field.AttributeLists;
foreach (var attrDeclare in attrDeclares)
{
foreach (var attr in attrDeclare.Attributes)
{
var type = model.GetTypeInfo(attr);
if (type.Type.IsSameType(nameof(JavaScript), nameof(EvalAtCompileAttribute)))
return true;
}
}
return false;
}
/// <summary>
/// The get member name.
/// </summary>
/// <param name="declarationNode">
/// The declaration node.
/// </param>
/// <returns>
/// The <see cref="string"/>.
/// </returns>
/// <exception cref="ArgumentNullException"><paramref name="declarationNode"/> is <see langword="null" />.</exception>
public string GetMemberName(MemberDeclarationSyntax declarationNode)
{
if (declarationNode == null)
{
throw new ArgumentNullException(nameof(declarationNode));
}
FieldDeclarationSyntax fieldDeclaration = declarationNode as FieldDeclarationSyntax;
if (fieldDeclaration != null)
{
return fieldDeclaration.Declaration.Variables[0].Identifier.ValueText;
}
PropertyDeclarationSyntax propertyDeclaration = declarationNode as PropertyDeclarationSyntax;
if (propertyDeclaration != null)
{
return propertyDeclaration.Identifier.ValueText;
}
return null;
}
/// <summary>
/// Initializes a new instance of the <see cref="MemberOrderHelper"/> struct.
/// </summary>
/// <param name="member">The member to wrap.</param>
/// <param name="checks">The element ordering checks.</param>
internal MemberOrderHelper(MemberDeclarationSyntax member, ElementOrderingChecks checks)
{
this.Member = member;
var modifiers = member.GetModifiers();
var type = member.Kind();
type = type == SyntaxKind.EventFieldDeclaration ? SyntaxKind.EventDeclaration : type;
this.elementPriority = checks.ElementType ? TypeMemberOrder.IndexOf(type) : 0;
this.modifierFlags = GetModifierFlags(modifiers, checks);
if (checks.AccessLevel)
{
if ((type == SyntaxKind.ConstructorDeclaration && this.modifierFlags.HasFlag(ModifierFlags.Static))
|| (type == SyntaxKind.MethodDeclaration && ((MethodDeclarationSyntax)member).ExplicitInterfaceSpecifier != null)
|| (type == SyntaxKind.PropertyDeclaration && ((PropertyDeclarationSyntax)member).ExplicitInterfaceSpecifier != null)
|| (type == SyntaxKind.IndexerDeclaration && ((IndexerDeclarationSyntax)member).ExplicitInterfaceSpecifier != null))
{
this.accessibilty = AccessLevel.Public;
}
else
{
this.accessibilty = AccessLevelHelper.GetAccessLevel(modifiers);
if (this.accessibilty == AccessLevel.NotSpecified)
{
if (member.Parent.IsKind(SyntaxKind.CompilationUnit) || member.Parent.IsKind(SyntaxKind.NamespaceDeclaration))
{
this.accessibilty = AccessLevel.Internal;
}
else
{
this.accessibilty = AccessLevel.Private;
}
}
}
}
else
{
this.accessibilty = AccessLevel.Public;
}
}
private static MemberDeclarationSyntax AfterMember(
SyntaxList<MemberDeclarationSyntax> members,
MemberDeclarationSyntax eventDeclaration)
{
if (eventDeclaration.Kind() == SyntaxKind.EventFieldDeclaration)
{
// Field style events go after the last field event, or after the last field.
var lastEvent = members.LastOrDefault(m => m is EventFieldDeclarationSyntax);
return lastEvent ?? LastField(members);
}
if (eventDeclaration.Kind() == SyntaxKind.EventDeclaration)
{
// Property style events go after existing events, then after existing constructors.
var lastEvent = members.LastOrDefault(m => m is EventDeclarationSyntax);
return lastEvent ?? LastConstructor(members);
}
return null;
}
private static SyntaxNode UpdateSyntaxRoot(MemberDeclarationSyntax memberDeclaration, ElementOrderingChecks checks, SyntaxNode syntaxRoot, IndentationOptions indentationOptions)
{
var parentDeclaration = memberDeclaration.Parent;
var memberToMove = new MemberOrderHelper(memberDeclaration, checks);
if (parentDeclaration is TypeDeclarationSyntax)
{
return HandleTypeDeclaration(memberToMove, (TypeDeclarationSyntax)parentDeclaration, checks, syntaxRoot, indentationOptions);
}
if (parentDeclaration is NamespaceDeclarationSyntax)
{
return HandleNamespaceDeclaration(memberToMove, (NamespaceDeclarationSyntax)parentDeclaration, checks, syntaxRoot, indentationOptions);
}
if (parentDeclaration is CompilationUnitSyntax)
{
return HandleCompilationUnitDeclaration(memberToMove, (CompilationUnitSyntax)parentDeclaration, checks, syntaxRoot, indentationOptions);
}
return syntaxRoot;
}
static AddTruthinessMethods()
{
SyntaxTree parsed =
SyntaxTree.ParseCompilationUnit(
@" private static bool __Truthy(object o)
{
if (o == null || (o is string && (string)o == string.Empty)) return false;
var type = o.GetType();
if (type.IsValueType)
{
return !o.Equals(Activator.CreateInstance(type));
}
return true;
}
"
);
TruthyMethod = parsed.Root.DescendentNodesAndSelf().OfType<MethodDeclarationSyntax>().Single();
}
private static SyntaxNode UpdateSyntaxRoot(MemberDeclarationSyntax memberDeclaration, ImmutableArray<OrderingTrait> elementOrder, SyntaxNode syntaxRoot, IndentationSettings indentationSettings)
{
var parentDeclaration = memberDeclaration.Parent;
var memberToMove = new MemberOrderHelper(memberDeclaration, elementOrder);
if (parentDeclaration is TypeDeclarationSyntax)
{
return HandleTypeDeclaration(memberToMove, (TypeDeclarationSyntax)parentDeclaration, elementOrder, syntaxRoot, indentationSettings);
}
if (parentDeclaration is NamespaceDeclarationSyntax)
{
return HandleNamespaceDeclaration(memberToMove, (NamespaceDeclarationSyntax)parentDeclaration, elementOrder, syntaxRoot, indentationSettings);
}
if (parentDeclaration is CompilationUnitSyntax)
{
return HandleCompilationUnitDeclaration(memberToMove, (CompilationUnitSyntax)parentDeclaration, elementOrder, syntaxRoot, indentationSettings);
}
return syntaxRoot;
}
public static string GetAccessModifiers(MemberDeclarationSyntax member, bool isInterface)
{
bool isStatic;
var acccessmodifiers = "";
var modifiers = member.GetModifiers();
bool isoverride = ShouldUseOverrideKeyword(member, isInterface);
if (modifiers.Any(SyntaxKind.PublicKeyword) || modifiers.Any(SyntaxKind.InternalKeyword) ||
modifiers.Any(SyntaxKind.ProtectedKeyword) || modifiers.Any(SyntaxKind.AbstractKeyword) ||
isInterface)
acccessmodifiers += ("public ");
if (!modifiers.Any(SyntaxKind.VirtualKeyword) && !isInterface && !isoverride)
acccessmodifiers += ("final ");
/// if (modifiers.Any(SyntaxKind.PrivateKeyword)) // Reflection cannot work with this, cant get address or set value
// acccessmodifiers += ("private ");
if (modifiers.Any(SyntaxKind.StaticKeyword))
{
acccessmodifiers += "static ";
}
if (member.GetModifiers().Any(SyntaxKind.AbstractKeyword))
acccessmodifiers += "abstract ";
if (isoverride)
acccessmodifiers += ("override ");
return acccessmodifiers;
}
public static SyntaxTriviaList Generate(MemberDeclarationSyntax memberDeclaration, DocumentationCommentGeneratorSettings settings = null)
{
if (memberDeclaration == null)
{
throw new ArgumentNullException(nameof(memberDeclaration));
}
switch (memberDeclaration.Kind())
{
case SyntaxKind.NamespaceDeclaration:
return(Generate((NamespaceDeclarationSyntax)memberDeclaration, settings));
case SyntaxKind.ClassDeclaration:
return(Generate((ClassDeclarationSyntax)memberDeclaration, settings));
case SyntaxKind.StructDeclaration:
return(Generate((StructDeclarationSyntax)memberDeclaration, settings));
case SyntaxKind.InterfaceDeclaration:
return(Generate((InterfaceDeclarationSyntax)memberDeclaration, settings));
case SyntaxKind.EnumDeclaration:
return(Generate((EnumDeclarationSyntax)memberDeclaration, settings));
case SyntaxKind.DelegateDeclaration:
return(Generate((DelegateDeclarationSyntax)memberDeclaration, settings));
case SyntaxKind.EnumMemberDeclaration:
return(Generate((EnumMemberDeclarationSyntax)memberDeclaration, settings));
case SyntaxKind.FieldDeclaration:
return(Generate((FieldDeclarationSyntax)memberDeclaration, settings));
case SyntaxKind.EventFieldDeclaration:
return(Generate((EventFieldDeclarationSyntax)memberDeclaration, settings));
case SyntaxKind.MethodDeclaration:
return(Generate((MethodDeclarationSyntax)memberDeclaration, settings));
case SyntaxKind.OperatorDeclaration:
return(Generate((OperatorDeclarationSyntax)memberDeclaration, settings));
case SyntaxKind.ConversionOperatorDeclaration:
return(Generate((ConversionOperatorDeclarationSyntax)memberDeclaration, settings));
case SyntaxKind.ConstructorDeclaration:
return(Generate((ConstructorDeclarationSyntax)memberDeclaration, settings));
case SyntaxKind.DestructorDeclaration:
return(Generate((DestructorDeclarationSyntax)memberDeclaration, settings));
case SyntaxKind.PropertyDeclaration:
return(Generate((PropertyDeclarationSyntax)memberDeclaration, settings));
case SyntaxKind.EventDeclaration:
return(Generate((EventDeclarationSyntax)memberDeclaration, settings));
case SyntaxKind.IndexerDeclaration:
return(Generate((IndexerDeclarationSyntax)memberDeclaration, settings));
default:
throw new ArgumentException("", nameof(memberDeclaration));
}
}
private bool IsPublic(MemberDeclarationSyntax member)
{
return(member.Modifiers.Where(m => m.IsKind(SyntaxKind.PublicKeyword)).Any());
}
private static Accessibility GetAccessModifier(SyntaxNodeAnalysisContext context, MemberDeclarationSyntax declaration, SyntaxTokenList modifiers)
{
if (!modifiers.ContainsAccessModifier())
{
if (modifiers.Any(SyntaxKind.PartialKeyword))
{
if (!declaration.IsKind(SyntaxKind.MethodDeclaration))
{
Accessibility?accessibility = GetPartialAccessModifier(context, declaration);
if (accessibility != null)
{
if (accessibility == Accessibility.NotApplicable)
{
return(declaration.GetDefaultExplicitAccessibility());
}
else
{
return(accessibility.Value);
}
}
}
}
else
{
return(declaration.GetDefaultExplicitAccessibility());
}
}
return(Accessibility.NotApplicable);
}
public static DocumentationCommentInserter Create(MemberDeclarationSyntax memberDeclaration)
{
return(Create(memberDeclaration.GetLeadingTrivia()));
}
private static void HandleMemberDeclaration(SyntaxNodeAnalysisContext context)
{
MemberDeclarationSyntax memberSyntax = (MemberDeclarationSyntax)context.Node;
var modifiers = memberSyntax.GetModifiers();
if (modifiers.Any(SyntaxKind.OverrideKeyword))
{
return;
}
DocumentationCommentTriviaSyntax documentation = memberSyntax.GetDocumentationCommentTriviaSyntax();
if (documentation == null)
{
return;
}
Location location;
ISymbol declaredSymbol = context.SemanticModel.GetDeclaredSymbol(memberSyntax, context.CancellationToken);
if (declaredSymbol == null && memberSyntax.IsKind(SyntaxKind.EventFieldDeclaration))
{
var eventFieldDeclarationSyntax = (EventFieldDeclarationSyntax)memberSyntax;
VariableDeclaratorSyntax firstVariable = eventFieldDeclarationSyntax.Declaration?.Variables.FirstOrDefault();
if (firstVariable != null)
{
declaredSymbol = context.SemanticModel.GetDeclaredSymbol(firstVariable, context.CancellationToken);
}
}
if (documentation.Content.GetFirstXmlElement(XmlCommentHelper.IncludeXmlTag) is XmlEmptyElementSyntax includeElement)
{
if (declaredSymbol == null)
{
return;
}
var rawDocumentation = declaredSymbol.GetDocumentationCommentXml(expandIncludes: true, cancellationToken: context.CancellationToken);
var completeDocumentation = XElement.Parse(rawDocumentation, LoadOptions.None);
var inheritDocElement = completeDocumentation.Nodes().OfType <XElement>().FirstOrDefault(element => element.Name == XmlCommentHelper.InheritdocXmlTag);
if (inheritDocElement == null)
{
return;
}
if (HasXmlCrefAttribute(inheritDocElement))
{
return;
}
location = includeElement.GetLocation();
}
else
{
XmlNodeSyntax inheritDocElement = documentation.Content.GetFirstXmlElement(XmlCommentHelper.InheritdocXmlTag);
if (inheritDocElement == null)
{
return;
}
if (HasXmlCrefAttribute(inheritDocElement))
{
return;
}
location = inheritDocElement.GetLocation();
}
// If we don't have a declared symbol we have some kind of field declaration. A field can not override or
// implement anything so we want to report a diagnostic.
if (declaredSymbol == null || !NamedTypeHelpers.IsImplementingAnInterfaceMember(declaredSymbol))
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, location));
}
}
public static Accessibility GetDefaultAccessibility(this MemberDeclarationSyntax memberDeclaration)
{
if (memberDeclaration == null)
{
throw new ArgumentNullException(nameof(memberDeclaration));
}
switch (memberDeclaration.Kind())
{
case SyntaxKind.ConstructorDeclaration:
{
if (((ConstructorDeclarationSyntax)memberDeclaration).IsStatic())
{
return(Accessibility.NotApplicable);
}
else
{
return(Accessibility.Private);
}
}
case SyntaxKind.DestructorDeclaration:
{
return(Accessibility.NotApplicable);
}
case SyntaxKind.MethodDeclaration:
{
var methodDeclaration = (MethodDeclarationSyntax)memberDeclaration;
if (methodDeclaration.Modifiers.Contains(SyntaxKind.PartialKeyword) ||
methodDeclaration.ExplicitInterfaceSpecifier != null ||
methodDeclaration.IsParentKind(SyntaxKind.InterfaceDeclaration))
{
return(Accessibility.NotApplicable);
}
else
{
return(Accessibility.Private);
}
}
case SyntaxKind.PropertyDeclaration:
{
var propertyDeclaration = (PropertyDeclarationSyntax)memberDeclaration;
if (propertyDeclaration.ExplicitInterfaceSpecifier != null ||
propertyDeclaration.IsParentKind(SyntaxKind.InterfaceDeclaration))
{
return(Accessibility.NotApplicable);
}
else
{
return(Accessibility.Private);
}
}
case SyntaxKind.IndexerDeclaration:
{
var indexerDeclaration = (IndexerDeclarationSyntax)memberDeclaration;
if (indexerDeclaration.ExplicitInterfaceSpecifier != null ||
indexerDeclaration.IsParentKind(SyntaxKind.InterfaceDeclaration))
{
return(Accessibility.NotApplicable);
}
else
{
return(Accessibility.Private);
}
}
case SyntaxKind.EventDeclaration:
{
var eventDeclaration = (EventDeclarationSyntax)memberDeclaration;
if (eventDeclaration.ExplicitInterfaceSpecifier != null)
{
return(Accessibility.NotApplicable);
}
else
{
return(Accessibility.Private);
}
}
case SyntaxKind.EventFieldDeclaration:
{
if (memberDeclaration.IsParentKind(SyntaxKind.InterfaceDeclaration))
{
return(Accessibility.NotApplicable);
}
else
{
return(Accessibility.Private);
}
}
case SyntaxKind.FieldDeclaration:
{
return(Accessibility.Private);
}
case SyntaxKind.OperatorDeclaration:
case SyntaxKind.ConversionOperatorDeclaration:
{
return(Accessibility.Public);
}
case SyntaxKind.ClassDeclaration:
case SyntaxKind.StructDeclaration:
case SyntaxKind.InterfaceDeclaration:
case SyntaxKind.EnumDeclaration:
case SyntaxKind.DelegateDeclaration:
{
if (memberDeclaration.IsParentKind(SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration))
{
return(Accessibility.Private);
}
else
{
return(Accessibility.Internal);
}
}
}
return(Accessibility.NotApplicable);
}
public static MemberDeclarationSyntax GetMemberAt(this MemberDeclarationSyntax declaration, int index)
{
SyntaxList <MemberDeclarationSyntax> members = GetMembers(declaration);
return(members[index]);
}
private static TDeclarationNode AddStatementsToMemberDeclaration <TDeclarationNode>(TDeclarationNode destinationMember, IEnumerable <SyntaxNode> statements, MemberDeclarationSyntax memberDeclaration) where TDeclarationNode : SyntaxNode
{
var body = memberDeclaration.GetBody();
if (body == null)
{
return(destinationMember);
}
var statementNodes = body.Statements.ToList();
statementNodes.AddRange(StatementGenerator.GenerateStatements(statements));
var finalBody = body.WithStatements(SyntaxFactory.List <StatementSyntax>(statementNodes));
var finalMember = memberDeclaration.WithBody(finalBody);
return(Cast <TDeclarationNode>(finalMember));
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, YieldStatementSyntax yieldStatement)
{
if (context.IsAnyRefactoringEnabled(
RefactoringIdentifiers.ChangeMemberTypeAccordingToYieldReturnExpression,
RefactoringIdentifiers.AddCastExpression,
RefactoringIdentifiers.CallToMethod,
RefactoringIdentifiers.CreateConditionFromBooleanExpression) &&
yieldStatement.IsYieldReturn() &&
yieldStatement.Expression != null &&
context.SupportsSemanticModel)
{
if (context.IsAnyRefactoringEnabled(
RefactoringIdentifiers.ChangeMemberTypeAccordingToYieldReturnExpression,
RefactoringIdentifiers.AddCastExpression,
RefactoringIdentifiers.CallToMethod))
{
MemberDeclarationSyntax containingMember = ReturnExpressionRefactoring.GetContainingMethodOrPropertyOrIndexer(yieldStatement.Expression);
if (containingMember != null)
{
TypeSyntax memberType = ReturnExpressionRefactoring.GetMemberType(containingMember);
if (memberType != null)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ITypeSymbol memberTypeSymbol = semanticModel
.GetTypeInfo(memberType, context.CancellationToken)
.Type;
if (memberTypeSymbol?.SpecialType != SpecialType.System_Collections_IEnumerable)
{
ITypeSymbol typeSymbol = semanticModel
.GetTypeInfo(yieldStatement.Expression, context.CancellationToken)
.Type;
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeMemberTypeAccordingToYieldReturnExpression) &&
typeSymbol?.IsErrorType() == false &&
(memberTypeSymbol == null ||
memberTypeSymbol.IsErrorType() ||
!SyntaxAnalyzer.IsGenericIEnumerable(memberTypeSymbol) ||
!((INamedTypeSymbol)memberTypeSymbol).TypeArguments[0].Equals(typeSymbol)))
{
TypeSyntax newType = QualifiedName(
ParseName("System.Collections.Generic"),
GenericName(
Identifier("IEnumerable"),
TypeArgumentList(
SingletonSeparatedList(
CSharpFactory.Type(typeSymbol)))));
context.RegisterRefactoring(
$"Change {ReturnExpressionRefactoring.GetText(containingMember)} type to 'IEnumerable<{typeSymbol.ToDisplayString(SyntaxUtility.DefaultSymbolDisplayFormat)}>'",
cancellationToken =>
{
return(ChangeTypeRefactoring.ChangeTypeAsync(
context.Document,
memberType,
newType,
cancellationToken));
});
}
if (context.IsAnyRefactoringEnabled(RefactoringIdentifiers.AddCastExpression, RefactoringIdentifiers.CallToMethod) &&
yieldStatement.Expression.Span.Contains(context.Span) &&
memberTypeSymbol?.IsNamedType() == true)
{
var namedTypeSymbol = (INamedTypeSymbol)memberTypeSymbol;
if (namedTypeSymbol.ConstructedFrom.SpecialType == SpecialType.System_Collections_Generic_IEnumerable_T)
{
ITypeSymbol argumentSymbol = namedTypeSymbol.TypeArguments[0];
if (argumentSymbol != typeSymbol)
{
ModifyExpressionRefactoring.ComputeRefactoring(
context,
yieldStatement.Expression,
argumentSymbol,
semanticModel);
}
}
}
}
}
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.CreateConditionFromBooleanExpression))
{
await CreateConditionFromBooleanExpressionRefactoring.ComputeRefactoringAsync(context, yieldStatement.Expression).ConfigureAwait(false);
}
}
}
private ClassDeclarationSyntax GenerateRequestType(SourceFileContext ctx)
{
var baseType = ctx.Type(Typ.Generic(Package.GenericBaseRequestTypDef, ResponseTyp));
var cls = Class(Modifier.Public, RequestTyp, baseType);
if (_restMethod.Description is object)
{
cls = cls.WithXmlDoc(XmlDoc.Summary(_restMethod.Description));
}
using (ctx.InClass(RequestTyp))
{
// Service and optionally "body"
var serviceParam = Parameter(ctx.Type <IClientService>(), "service");
ParameterSyntax bodyParam = null;
var extraParameters = new List <ParameterSyntax> {
serviceParam
};
var bodyDeclarations = new MemberDeclarationSyntax[0];
if (BodyTyp is object)
{
var bodyProperty = AutoProperty(Modifier.None, ctx.Type(BodyTyp), "Body", hasSetter: true)
.WithXmlDoc(XmlDoc.Summary("Gets or sets the body of this request."));
var bodyMethod = Method(Modifier.Protected | Modifier.Override, ctx.Type <object>(), "GetBody")()
.WithBody(Return(bodyProperty))
.WithXmlDoc(XmlDoc.Summary("Returns the body of the request."));
bodyDeclarations = new MemberDeclarationSyntax[] { bodyProperty, bodyMethod };
bodyParam = Parameter(ctx.Type(BodyTyp), "body");
extraParameters.Add(bodyParam);
}
var mediaDownloaderProperty = SupportsMediaDownload
? AutoProperty(Modifier.Public, ctx.Type <IMediaDownloader>(), "MediaDownloader", hasSetter: true, setterIsPrivate: true)
.WithXmlDoc(XmlDoc.Summary("Gets the media downloader."))
: null;
var parameters = CreateParameterList(RequestTyp);
var requiredParameters = parameters
.TakeWhile(p => p.IsRequired)
.Select(p => (param: p, decl: Parameter(ctx.Type(p.Typ), p.CodeParameterName)))
.ToList();
var assignments = requiredParameters
.Select(p => Field(0, ctx.Type(p.param.Typ), p.param.PropertyName).Assign(p.decl)).ToList();
if (BodyTyp is object)
{
var bodyProperty = (PropertyDeclarationSyntax)bodyDeclarations[0];
assignments.Add(bodyProperty.Assign(bodyParam));
}
if (SupportsMediaDownload)
{
assignments.Add(mediaDownloaderProperty.Assign(New(ctx.Type <MediaDownloader>())(serviceParam)));
}
var allCtorParameters = extraParameters.Concat(requiredParameters.Select(p => p.decl)).ToArray();
var ctor = Ctor(Modifier.Public, cls, BaseInitializer(serviceParam))(allCtorParameters)
.WithXmlDoc(XmlDoc.Summary($"Constructs a new {PascalCasedName} request."))
.WithBlockBody(assignments.Concat <object>(new[] { InvocationExpression(IdentifierName("InitParameters")) }).ToArray());
var methodName = Property(Modifier.Public | Modifier.Override, ctx.Type <string>(), "MethodName")
.WithGetBody(Name)
.WithXmlDoc(XmlDoc.Summary("Gets the method name."));
var httpMethod = Property(Modifier.Public | Modifier.Override, ctx.Type <string>(), "HttpMethod")
.WithGetBody(_restMethod.HttpMethod)
.WithXmlDoc(XmlDoc.Summary("Gets the HTTP method."));
var restPath = Property(Modifier.Public | Modifier.Override, ctx.Type <string>(), "RestPath")
.WithGetBody(_restMethod.Path)
.WithXmlDoc(XmlDoc.Summary("Gets the REST path."));
var initParameters = Method(Modifier.Protected | Modifier.Override, VoidType, "InitParameters")()
.WithBlockBody(
BaseExpression().Call("InitParameters")(),
parameters.Select(p => p.GenerateInitializer(ctx)).ToArray())
.WithXmlDoc(XmlDoc.Summary($"Initializes {PascalCasedName} parameter list."));
// TODO: Media downloader members
cls = cls.AddMembers(ctor);
cls = cls.AddMembers(parameters.SelectMany(p => p.GenerateDeclarations(ctx)).ToArray());
cls = cls.AddMembers(bodyDeclarations);
cls = cls.AddMembers(methodName, httpMethod, restPath, initParameters);
if (SupportsMediaDownload)
{
cls = cls.AddMembers(mediaDownloaderProperty);
cls = AddMediaDownloadMethods(mediaDownloaderProperty, cls, ctx);
}
}
return(cls);
}
/// <summary>
/// Add the field and respect StyleCop ordering.
/// </summary>
/// <param name="generator">The <see cref="SyntaxGenerator"/>.</param>
/// <param name="containingType">The containing type.</param>
/// <param name="member">The <see cref="MemberDeclarationSyntax"/>.</param>
/// <param name="comparer">The <see cref="IComparer{MemberDeclarationSyntax}"/>. If null <see cref="MemberDeclarationComparer.Default"/> is used.</param>
/// <returns>The <paramref name="containingType"/> with <paramref name="member"/>.</returns>
public static TypeDeclarationSyntax AddSorted(this SyntaxGenerator generator, TypeDeclarationSyntax containingType, MemberDeclarationSyntax member, IComparer <MemberDeclarationSyntax>?comparer = null)
{
if (generator is null)
{
throw new System.ArgumentNullException(nameof(generator));
}
if (containingType is null)
{
throw new System.ArgumentNullException(nameof(containingType));
}
if (member is null)
{
throw new System.ArgumentNullException(nameof(member));
}
comparer ??= MemberDeclarationComparer.Default;
if (!member.HasLeadingTrivia)
{
member = member.WithLeadingTrivia(SyntaxFactory.Whitespace(containingType.LeadingWhitespace() + " "));
}
#pragma warning disable CA1062 // Already checked
if (!member.HasTrailingTrivia)
#pragma warning restore CA1062 // Validate arguments of public methods
{
member = member.WithTrailingLineFeed();
}
for (var i = 0; i < containingType.Members.Count; i++)
{
var existing = containingType.Members[i];
if (comparer.Compare(member, existing) < 0)
{
if (TryMoveDirectives(existing.GetFirstToken(), member, out var token, out var memberWithDirectives))
{
containingType = (TypeDeclarationSyntax)generator.InsertNodesBefore(
containingType,
existing,
new[] { memberWithDirectives });
return(containingType.ReplaceToken(containingType.Members[i + 1].GetFirstToken(), token));
}
if (containingType.Members.TryElementAt(i - 1, out var last) &&
ShouldAddLeadingLineFeed(last, member))
{
member = member.WithLeadingLineFeed();
}
if (ShouldAddLeadingLineFeed(member, existing))
{
containingType = (TypeDeclarationSyntax)generator.ReplaceNode(containingType, containingType.Members[i], existing.WithLeadingLineFeed());
}
#pragma warning disable CA1062 /// Already checked
return((TypeDeclarationSyntax)generator.InsertNodesBefore(containingType, containingType.Members[i], new[] { member }));
#pragma warning restore CA1062 // Validate arguments of public methods
}
}
if (TryMoveDirectives(containingType.CloseBraceToken, member, out var closeBraceToken, out var memberWithDirective))
{
containingType = (TypeDeclarationSyntax)generator.AddMembers(
containingType,
memberWithDirective);
return(containingType.ReplaceToken(containingType.CloseBraceToken, closeBraceToken));
}
private static SyntaxNode Refactor(MemberDeclarationSyntax member)
{
switch (member.Parent.Kind())
{
case SyntaxKind.CompilationUnit:
{
var parent = (CompilationUnitSyntax)member.Parent;
SyntaxList <MemberDeclarationSyntax> members = parent.Members;
int index = members.IndexOf(member);
return(parent.WithMembers(members.Insert(index + 1, member)));
}
case SyntaxKind.NamespaceDeclaration:
{
var parent = (NamespaceDeclarationSyntax)member.Parent;
SyntaxList <MemberDeclarationSyntax> members = parent.Members;
int index = members.IndexOf(member);
if (index == 0 &&
parent.OpenBraceToken.GetFullSpanEndLine() == member.GetFullSpanStartLine())
{
member = member.WithLeadingTrivia(member.GetLeadingTrivia().Insert(0, NewLineTrivia()));
}
return(parent.WithMembers(members.Insert(index + 1, member)));
}
case SyntaxKind.ClassDeclaration:
{
var parent = (ClassDeclarationSyntax)member.Parent;
SyntaxList <MemberDeclarationSyntax> members = parent.Members;
int index = members.IndexOf(member);
if (index == 0 &&
parent.OpenBraceToken.GetFullSpanEndLine() == member.GetFullSpanStartLine())
{
member = member.WithLeadingTrivia(member.GetLeadingTrivia().Insert(0, NewLineTrivia()));
}
return(parent.WithMembers(members.Insert(index + 1, member)));
}
case SyntaxKind.StructDeclaration:
{
var parent = (StructDeclarationSyntax)member.Parent;
SyntaxList <MemberDeclarationSyntax> members = parent.Members;
int index = members.IndexOf(member);
if (index == 0 &&
parent.OpenBraceToken.GetFullSpanEndLine() == member.GetFullSpanStartLine())
{
member = member.WithLeadingTrivia(member.GetLeadingTrivia().Insert(0, NewLineTrivia()));
}
return(parent.WithMembers(members.Insert(index + 1, member)));
}
case SyntaxKind.InterfaceDeclaration:
{
var parent = (InterfaceDeclarationSyntax)member.Parent;
SyntaxList <MemberDeclarationSyntax> members = parent.Members;
int index = members.IndexOf(member);
if (index == 0 &&
parent.OpenBraceToken.GetFullSpanEndLine() == member.GetFullSpanStartLine())
{
member = member.WithLeadingTrivia(member.GetLeadingTrivia().Insert(0, NewLineTrivia()));
}
return(parent.WithMembers(members.Insert(index + 1, member)));
}
}
return(null);
}
private void ProcessMemberDeclaration(
SyntaxTreeAnalysisContext context,
CodeStyleOption2 <AccessibilityModifiersRequired> option, MemberDeclarationSyntax member)
{
if (member.IsKind(SyntaxKind.NamespaceDeclaration, out NamespaceDeclarationSyntax namespaceDeclaration))
{
ProcessMembers(context, option, namespaceDeclaration.Members);
}
// If we have a class or struct, recurse inwards.
if (member.IsKind(SyntaxKind.ClassDeclaration, out TypeDeclarationSyntax typeDeclaration) ||
member.IsKind(SyntaxKind.StructDeclaration, out typeDeclaration) ||
member.IsKind(SyntaxKind.RecordDeclaration, out typeDeclaration))
{
ProcessMembers(context, option, typeDeclaration.Members);
}
#if false
// Add this once we have the language version for C# that supports accessibility
// modifiers on interface methods.
if (option.Value == AccessibilityModifiersRequired.Always &&
member.IsKind(SyntaxKind.InterfaceDeclaration, out typeDeclaration))
{
// Only recurse into an interface if the user wants accessibility modifiers on
ProcessTypeDeclaration(context, generator, option, typeDeclaration);
}
#endif
// Have to have a name to report the issue on.
var name = member.GetNameToken();
if (name.Kind() == SyntaxKind.None)
{
return;
}
// Certain members never have accessibility. Don't bother reporting on them.
if (!SyntaxFacts.CanHaveAccessibility(member))
{
return;
}
// This analyzer bases all of its decisions on the accessibility
var accessibility = SyntaxFacts.GetAccessibility(member);
// Omit will flag any accessibility values that exist and are default
// The other options will remove or ignore accessibility
var isOmit = option.Value == AccessibilityModifiersRequired.OmitIfDefault;
if (isOmit)
{
if (accessibility == Accessibility.NotApplicable)
{
return;
}
var parentKind = member.Parent.Kind();
switch (parentKind)
{
// Check for default modifiers in namespace and outside of namespace
case SyntaxKind.CompilationUnit:
case SyntaxKind.NamespaceDeclaration:
{
// Default is internal
if (accessibility != Accessibility.Internal)
{
return;
}
}
break;
case SyntaxKind.ClassDeclaration:
case SyntaxKind.RecordDeclaration:
case SyntaxKind.StructDeclaration:
{
// Inside a type, default is private
if (accessibility != Accessibility.Private)
{
return;
}
}
break;
default:
return; // Unknown parent kind, don't do anything
}
}
else
{
// Mode is always, so we have to flag missing modifiers
if (accessibility != Accessibility.NotApplicable)
{
return;
}
}
// Have an issue to flag, either add or remove. Report issue to user.
var additionalLocations = ImmutableArray.Create(member.GetLocation());
context.ReportDiagnostic(DiagnosticHelper.Create(
Descriptor,
name.GetLocation(),
option.Notification.Severity,
additionalLocations: additionalLocations,
properties: null));
}
public static LocalDeclarationMap GetLocalDeclarationMap(this MemberDeclarationSyntax member)
{
var result = s_declarationCache.GetValue(member, s_createLocalDeclarationMap);
return(new LocalDeclarationMap(result));
}
private static void RegisterRefactoring(RefactoringContext context, MemberDeclarationSyntax memberDeclaration, BaseDocumentationCommentData data)
{
context.RegisterRefactoring(
GetTitle(memberDeclaration, data.Origin),
cancellationToken => RefactorAsync(context.Document, memberDeclaration, data.Comment, cancellationToken));
}
private static Dictionary <string, ImmutableArray <SyntaxToken> > CreateLocalDeclarationMap(MemberDeclarationSyntax member)
{
var dictionary = DeclarationFinder.GetAllDeclarations(member);
return(dictionary.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.AsImmutable <SyntaxToken>()));
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, MemberDeclarationSyntax declaration)
{
if (!context.IsRefactoringEnabled(RefactoringIdentifiers.IntroduceConstructor))
{
return;
}
List <MemberDeclarationSyntax> members = null;
SyntaxKind kind = declaration.Kind();
if (kind.Is(SyntaxKind.PropertyDeclaration, SyntaxKind.FieldDeclaration))
{
if (context.Span.Contains(declaration.Span))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
if (CanBeAssignedFromConstructor(declaration, context.Span, semanticModel, context.CancellationToken))
{
members = new List <MemberDeclarationSyntax>()
{
declaration
};
}
}
}
else if (kind.Is(SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration))
{
SemanticModel semanticModel = null;
foreach (MemberDeclarationSyntax member in SyntaxInfo.MemberDeclarationListInfo(declaration).Members)
{
if (context.Span.Contains(member.Span))
{
if (semanticModel == null)
{
semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
}
if (CanBeAssignedFromConstructor(member, context.Span, semanticModel, context.CancellationToken))
{
(members ??= new List <MemberDeclarationSyntax>()).Add(member);
}
}
}
}
if (members == null)
{
return;
}
context.RegisterRefactoring(
"Introduce constructor",
ct => RefactorAsync(context.Document, declaration, members, ct),
RefactoringIdentifiers.IntroduceConstructor);
}
private static void Analyze(SyntaxNodeAnalysisContext context, SyntaxList <MemberDeclarationSyntax> members)
{
int count = members.Count;
if (count <= 1)
{
return;
}
SyntaxTree tree = context.Node.SyntaxTree;
bool?isPrevSingleLine = null;
for (int i = 1; i < count; i++)
{
MemberDeclarationSyntax prevMember = members[i - 1];
SyntaxTriviaList trailingTrivia = prevMember.GetTrailingTrivia();
SyntaxTrivia lastTrailingTrivia = trailingTrivia.LastOrDefault();
if (!lastTrailingTrivia.IsKind(SyntaxKind.EndOfLineTrivia))
{
isPrevSingleLine = false;
continue;
}
MemberDeclarationSyntax member = members[i];
SyntaxTrivia documentationCommentTrivia = member.GetDocumentationCommentTrivia();
bool hasDocumentationComment = !documentationCommentTrivia.IsKind(SyntaxKind.None);
if (!hasDocumentationComment)
{
bool isSingleLine = tree.IsSingleLineSpan(member.Span, context.CancellationToken);
if (isSingleLine)
{
if (isPrevSingleLine == null)
{
isPrevSingleLine = tree.IsSingleLineSpan(prevMember.Span, context.CancellationToken);
}
if (isPrevSingleLine == true)
{
isPrevSingleLine = isSingleLine;
continue;
}
}
isPrevSingleLine = isSingleLine;
}
else
{
isPrevSingleLine = null;
}
if (member
.GetLeadingTrivia()
.FirstOrDefault()
.IsKind(SyntaxKind.EndOfLineTrivia))
{
continue;
}
int end = (hasDocumentationComment) ? documentationCommentTrivia.SpanStart : member.SpanStart;
if (tree.GetLineCount(TextSpan.FromBounds(prevMember.Span.End, end), context.CancellationToken) == 2)
{
DiagnosticHelpers.ReportDiagnostic(context,
DiagnosticDescriptors.AddEmptyLineBetweenDeclarations,
lastTrailingTrivia);
}
}
}
private static CompilationResult CompileInternal(string originalName, string cSharpSafeName, MemberDeclarationSyntax @class, bool isIndex, Dictionary <string, string> extentions = null)
{
var name = cSharpSafeName + "." + Guid.NewGuid() + (isIndex ? IndexExtension : TransformerExtension);
var @namespace = RoslynHelper.CreateNamespace(isIndex ? IndexNamespace : TransformerNamespace)
.WithMembers(SyntaxFactory.SingletonList(@class));
var res = GetUsingDirectiveAndSyntaxTreesAndRefrences(extentions);
var compilationUnit = SyntaxFactory.CompilationUnit()
.WithUsings(RoslynHelper.CreateUsings(res.UsingDirectiveSyntaxes))
.WithMembers(SyntaxFactory.SingletonList <MemberDeclarationSyntax>(@namespace))
.NormalizeWhitespace();
SyntaxNode formatedCompilationUnit;
using (var workspace = new AdhocWorkspace())
{
formatedCompilationUnit = Formatter.Format(compilationUnit, workspace);
}
string sourceFile = null;
if (EnableDebugging)
{
sourceFile = Path.Combine(Path.GetTempPath(), name + ".cs");
File.WriteAllText(sourceFile, formatedCompilationUnit.ToFullString(), Encoding.UTF8);
}
var st = EnableDebugging
? SyntaxFactory.ParseSyntaxTree(File.ReadAllText(sourceFile), path: sourceFile, encoding: Encoding.UTF8)
: SyntaxFactory.ParseSyntaxTree(formatedCompilationUnit.ToFullString());
res.SyntaxTrees.Add(st);
var syntaxTrees = res.SyntaxTrees;
var compilation = CSharpCompilation.Create(
assemblyName: name + ".dll",
syntaxTrees: syntaxTrees,
references: res.References,
options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
.WithOptimizationLevel(OptimizationLevel.Release)
);
var code = formatedCompilationUnit.SyntaxTree.ToString();
var asm = new MemoryStream();
var pdb = EnableDebugging ? new MemoryStream() : null;
var result = compilation.Emit(asm, pdb, options: new EmitOptions(debugInformationFormat: DebugInformationFormat.PortablePdb));
if (result.Success == false)
{
IEnumerable <Diagnostic> failures = result.Diagnostics
.Where(diagnostic => diagnostic.IsWarningAsError || diagnostic.Severity == DiagnosticSeverity.Error);
var sb = new StringBuilder();
sb.AppendLine($"Failed to compile {(isIndex ? "index" : "transformer")} {originalName}");
sb.AppendLine();
sb.AppendLine(code);
sb.AppendLine();
foreach (var diagnostic in failures)
{
sb.AppendLine(diagnostic.ToString());
}
if (isIndex)
{
throw new IndexCompilationException(sb.ToString());
}
throw new TransformerCompilationException(sb.ToString());
}
asm.Position = 0;
Assembly assembly;
if (EnableDebugging)
{
pdb.Position = 0;
assembly = AssemblyLoadContext.Default.LoadFromStream(asm, pdb);
}
else
{
assembly = AssemblyLoadContext.Default.LoadFromStream(asm);
}
return(new CompilationResult
{
Code = code,
Type = assembly.GetType($"{(isIndex ? IndexNamespace : TransformerNamespace)}.{cSharpSafeName}")
});
}
public static bool IsProtected(this MemberDeclarationSyntax field) => field.HasModifier(ProtectedKeyword);
private static void AnalyzeLogicalNotExpression(SyntaxNodeAnalysisContext context)
{
var logicalNot = (PrefixUnaryExpressionSyntax)context.Node;
ExpressionSyntax expression = logicalNot.Operand?.WalkDownParentheses();
if (expression?.IsMissing != false)
{
return;
}
switch (expression.Kind())
{
case SyntaxKind.TrueLiteralExpression:
case SyntaxKind.FalseLiteralExpression:
case SyntaxKind.LogicalNotExpression:
{
ReportDiagnostic();
break;
}
case SyntaxKind.EqualsExpression:
{
MemberDeclarationSyntax memberDeclaration = logicalNot.FirstAncestor <MemberDeclarationSyntax>();
if (memberDeclaration is OperatorDeclarationSyntax operatorDeclaration &&
operatorDeclaration.OperatorToken.IsKind(SyntaxKind.ExclamationEqualsToken))
{
return;
}
ReportDiagnostic();
break;
}
case SyntaxKind.NotEqualsExpression:
{
MemberDeclarationSyntax memberDeclaration = logicalNot.FirstAncestor <MemberDeclarationSyntax>();
if (memberDeclaration is OperatorDeclarationSyntax operatorDeclaration &&
operatorDeclaration.OperatorToken.IsKind(SyntaxKind.EqualsEqualsToken))
{
return;
}
ReportDiagnostic();
break;
}
case SyntaxKind.LessThanExpression:
case SyntaxKind.LessThanOrEqualExpression:
case SyntaxKind.GreaterThanExpression:
case SyntaxKind.GreaterThanOrEqualExpression:
{
var binaryExpression = (BinaryExpressionSyntax)expression;
if (IsNumericType(binaryExpression.Left, context.SemanticModel, context.CancellationToken) &&
IsNumericType(binaryExpression.Right, context.SemanticModel, context.CancellationToken))
{
ReportDiagnostic();
}
break;
}
}
void ReportDiagnostic()
{
DiagnosticHelpers.ReportDiagnostic(context, DiagnosticDescriptors.SimplifyLogicalNegation, logicalNot);
}
}
public static bool IsConstant(this MemberDeclarationSyntax member) => member.HasModifier(ConstKeyword);
public static void MemberDeclarationComparerCompare(MemberDeclarationSyntax x, MemberDeclarationSyntax y)
{
Assert.AreEqual(-1, MemberDeclarationComparer.Compare(x, y));
Assert.AreEqual(1, MemberDeclarationComparer.Compare(y, x));
Assert.AreEqual(0, MemberDeclarationComparer.Compare(x, x));
Assert.AreEqual(0, MemberDeclarationComparer.Compare(y, y));
}
private static bool IsEmptyMethod(MemberDeclarationSyntax node) => node is MethodDeclarationSyntax methodDeclarationSyntax &&
public static bool IsPublic(this MemberDeclarationSyntax field) => field.HasModifier(PublicKeyword);
public static CompilationUnitSyntax RemoveMember(CompilationUnitSyntax compilationUnit, MemberDeclarationSyntax member)
{
if (compilationUnit == null)
{
throw new ArgumentNullException(nameof(compilationUnit));
}
if (member == null)
{
throw new ArgumentNullException(nameof(member));
}
int index = compilationUnit.Members.IndexOf(member);
MemberDeclarationSyntax newMember = RemoveSingleLineDocumentationComment(member);
compilationUnit = compilationUnit.WithMembers(compilationUnit.Members.ReplaceAt(index, newMember));
return(compilationUnit.RemoveNode(compilationUnit.Members[index], GetRemoveOptions(newMember)));
}
public static InterfaceDeclarationSyntax RemoveMember(InterfaceDeclarationSyntax interfaceDeclaration, MemberDeclarationSyntax member)
{
if (interfaceDeclaration == null)
{
throw new ArgumentNullException(nameof(interfaceDeclaration));
}
if (member == null)
{
throw new ArgumentNullException(nameof(member));
}
int index = interfaceDeclaration.Members.IndexOf(member);
MemberDeclarationSyntax newMember = RemoveSingleLineDocumentationComment(member);
interfaceDeclaration = interfaceDeclaration.WithMembers(interfaceDeclaration.Members.ReplaceAt(index, newMember));
return(interfaceDeclaration.RemoveNode(interfaceDeclaration.Members[index], GetRemoveOptions(newMember)));
}
public override void ExitFoxmethod([NotNull] XP.FoxmethodContext context)
{
context.SetSequencePoint(context.T.Start, context.end.Stop);
var idName = context.Id.Get <SyntaxToken>();
var mods = context.Modifiers?.GetList <SyntaxToken>() ?? DefaultMethodModifiers(false, false, context.TypeParameters != null);
var isExtern = mods.Any((int)SyntaxKind.ExternKeyword);
var isAbstract = mods.Any((int)SyntaxKind.AbstractKeyword);
var hasNoBody = isExtern || isAbstract;
var mName = idName.Text;
if (mName.EndsWith("_ACCESS", StringComparison.OrdinalIgnoreCase))
{
mName = mName.Substring(0, mName.Length - "_ACCESS".Length);
}
else if (mName.EndsWith("_ASSIGN", StringComparison.OrdinalIgnoreCase))
{
mName = mName.Substring(0, mName.Length - "_ASSIGN".Length);
}
idName = SyntaxFactory.MakeIdentifier(mName);
bool isAccessAssign = this.isAccessAssign(context.RealType);
var attributes = context.Attributes?.GetList <AttributeListSyntax>() ?? EmptyList <AttributeListSyntax>();
bool hasExtensionAttribute = false;
if (isAccessAssign)
{
var vomods = _pool.Allocate();
vomods.Add(SyntaxFactory.MakeToken(SyntaxKind.PrivateKeyword));
if (mods.Any((int)SyntaxKind.StaticKeyword))
{
vomods.Add(SyntaxFactory.MakeToken(SyntaxKind.StaticKeyword));
}
if (mods.Any((int)SyntaxKind.UnsafeKeyword))
{
vomods.Add(SyntaxFactory.MakeToken(SyntaxKind.UnsafeKeyword));
}
mods = vomods.ToList <SyntaxToken>();
_pool.Free(vomods);
}
if (!isExtern)
{
isExtern = hasDllImport(attributes);
hasNoBody = hasNoBody || isExtern;
}
if (isExtern && !mods.Any((int)SyntaxKind.ExternKeyword))
{
// Add Extern Keyword to modifiers
var m1 = _pool.Allocate();
m1.AddRange(mods);
if (!m1.Any((int)SyntaxKind.ExternKeyword))
{
m1.Add(SyntaxFactory.MakeToken(SyntaxKind.ExternKeyword));
}
mods = m1.ToList <SyntaxToken>();
_pool.Free(m1);
}
var parameters = context.ParamList?.Get <ParameterListSyntax>() ?? EmptyParameterList();
var body = hasNoBody ? null : context.StmtBlk.Get <BlockSyntax>();
var returntype = context.Type?.Get <TypeSyntax>();
if (returntype == null)
{
if (context.RealType == XP.ASSIGN)
{
returntype = VoidType();
}
else // method and access
{
returntype = _getMissingType();
returntype.XNode = context;
}
}
else
{
returntype.XVoDecl = true;
}
var oldbody = body;
ImplementClipperAndPSZ(context, ref attributes, ref parameters, ref body, ref returntype);
if (body != oldbody)
{
context.StmtBlk.Put(body);
}
if (context.RealType == XP.ASSIGN)
{
// Assign does not need a return.
// So do not add missing returns
returntype = VoidType();
}
else if (context.StmtBlk != null && !hasNoBody)
{
body = AddMissingReturnStatement(body, context.StmtBlk, returntype);
}
MemberDeclarationSyntax m = _syntaxFactory.MethodDeclaration(
attributeLists: attributes,
modifiers: mods,
returnType: returntype,
explicitInterfaceSpecifier: null,
identifier: idName,
typeParameterList: context.TypeParameters?.Get <TypeParameterListSyntax>(),
parameterList: parameters,
constraintClauses: MakeList <TypeParameterConstraintClauseSyntax>(context._ConstraintsClauses),
body: body,
expressionBody: null, // TODO: (grammar) expressionBody methods
semicolonToken: (!hasNoBody && context.StmtBlk != null) ? null : SyntaxFactory.MakeToken(SyntaxKind.SemicolonToken));
if (hasExtensionAttribute)
{
m = m.WithAdditionalDiagnostics(new SyntaxDiagnosticInfo(ErrorCode.ERR_ExplicitExtension));
}
bool separateMethod = false;
context.Put(m);
if (isAccessAssign && !separateMethod)
{
if (context.Data.HasClipperCallingConvention && context.CallingConvention != null)
{
m = m.WithAdditionalDiagnostics(new SyntaxDiagnosticInfo(
ErrorCode.ERR_NoClipperCallingConventionForAccessAssign));
}
context.Put(m);
ClassEntities.Peek().AddVoPropertyAccessor(context, context.RealType, idName);
}
}
public static MemberDeclarationSyntax SetModifiers(this MemberDeclarationSyntax declaration, SyntaxTokenList modifiers)
{
if (declaration == null)
{
throw new ArgumentNullException(nameof(declaration));
}
switch (declaration.Kind())
{
case SyntaxKind.ClassDeclaration:
return(((ClassDeclarationSyntax)declaration).WithModifiers(modifiers));
case SyntaxKind.ConstructorDeclaration:
return(((ConstructorDeclarationSyntax)declaration).WithModifiers(modifiers));
case SyntaxKind.OperatorDeclaration:
return(((OperatorDeclarationSyntax)declaration).WithModifiers(modifiers));
case SyntaxKind.ConversionOperatorDeclaration:
return(((ConversionOperatorDeclarationSyntax)declaration).WithModifiers(modifiers));
case SyntaxKind.DelegateDeclaration:
return(((DelegateDeclarationSyntax)declaration).WithModifiers(modifiers));
case SyntaxKind.DestructorDeclaration:
return(((DestructorDeclarationSyntax)declaration).WithModifiers(modifiers));
case SyntaxKind.EnumDeclaration:
return(((EnumDeclarationSyntax)declaration).WithModifiers(modifiers));
case SyntaxKind.EventDeclaration:
return(((EventDeclarationSyntax)declaration).WithModifiers(modifiers));
case SyntaxKind.EventFieldDeclaration:
return(((EventFieldDeclarationSyntax)declaration).WithModifiers(modifiers));
case SyntaxKind.FieldDeclaration:
return(((FieldDeclarationSyntax)declaration).WithModifiers(modifiers));
case SyntaxKind.IndexerDeclaration:
return(((IndexerDeclarationSyntax)declaration).WithModifiers(modifiers));
case SyntaxKind.InterfaceDeclaration:
return(((InterfaceDeclarationSyntax)declaration).WithModifiers(modifiers));
case SyntaxKind.MethodDeclaration:
return(((MethodDeclarationSyntax)declaration).WithModifiers(modifiers));
case SyntaxKind.PropertyDeclaration:
return(((PropertyDeclarationSyntax)declaration).WithModifiers(modifiers));
case SyntaxKind.StructDeclaration:
return(((StructDeclarationSyntax)declaration).WithModifiers(modifiers));
default:
{
Debug.Assert(false, declaration.Kind().ToString());
return(declaration);
}
}
}
public override void ExitFoxclass([NotNull] XP.FoxclassContext context)
{
var fieldNames = new List <String>();
var members = _pool.Allocate <MemberDeclarationSyntax>();
var generated = ClassEntities.Pop();
var mods = context.Modifiers?.GetList <SyntaxToken>() ?? TokenListWithDefaultVisibility();
context.Data.Partial = mods.Any((int)SyntaxKind.PartialKeyword);
var baseTypes = _pool.AllocateSeparated <BaseTypeSyntax>();
var baseType = context.BaseType?.Get <TypeSyntax>();
if (baseType != null)
{
baseTypes.Add(_syntaxFactory.SimpleBaseType(baseType));
}
if (generated.Members.Count > 0)
{
members.AddRange(generated.Members);
}
if (generated.VoProperties != null)
{
foreach (var vop in generated.VoProperties.Values)
{
var prop = GenerateVoProperty(vop, context);
if (prop != null)
{
members.Add(prop);
}
}
}
// Collect list of FieldNames from clsvarscontext to prevent generating properties twice
foreach (var mCtx in context._Members)
{
if (mCtx is XP.FoxclsvarsContext fcfc)
{
var mem = fcfc.Member;
foreach (var v in mem._Vars)
{
fieldNames.Add(v.GetText().ToLower());
}
var list = mem.CsNode as List <MemberDeclarationSyntax>;
if (list != null)
{
foreach (var m1 in list)
{
members.Add(m1);
}
}
}
}
// Do this after VOProps generation because GenerateVOProperty sets the members
// for Access & Assign to NULL
ConstructorDeclarationSyntax ctor = null;
foreach (var mCtx in context._Members)
{
if (mCtx is XP.FoxclsvarinitContext cvi)
{
var fld = cvi.Member.F.Name.GetText();
if (!fieldNames.Contains(fld.ToLower()))
{
if (mCtx.CsNode != null)
{
members.Add(mCtx.Get <MemberDeclarationSyntax>());
}
}
else
{
// field is declared and initialized. No need to generate a second property or field.
}
}
else if (mCtx is XP.FoximplementsContext fic)
{
var clause = fic.Member as XP.FoximplementsclauseContext;
var type = clause.Type.Get <TypeSyntax>();
if (baseTypes.Count > 0)
{
baseTypes.AddSeparator(SyntaxFactory.MakeToken(SyntaxKind.CommaToken));
}
baseTypes.Add(_syntaxFactory.SimpleBaseType(type));
}
else if (mCtx is XP.FoxclsmethodContext cmc)
{
if (cmc.Member.CsNode is MemberDeclarationSyntax mds)
{
members.Add(mds);
}
}
else if (mCtx is XP.FoxaddobjectContext fac)
{
var prop = fac.Get <MemberDeclarationSyntax>();
members.Add(prop);
}
else
{
if (mCtx.CsNode is MemberDeclarationSyntax mds)
{
members.Add(mds);
if (mds is ConstructorDeclarationSyntax)
{
ctor = mds as ConstructorDeclarationSyntax;
}
}
}
}
generated.Free();
if (ctor != null)
{
var newlist = members.ToList();
members.Clear();
foreach (var mem in newlist)
{
if (mem != ctor)
{
members.Add(mem);
}
}
ctor = createConstructor(context, members, fieldNames, ctor);
members.Add(ctor);
}
else
{
ctor = createConstructor(context, members, fieldNames, null);
members.Add(ctor);
}
MemberDeclarationSyntax m = _syntaxFactory.ClassDeclaration(
attributeLists: context.Attributes?.GetList <AttributeListSyntax>() ?? EmptyList <AttributeListSyntax>(),
modifiers: mods,
keyword: SyntaxFactory.MakeToken(SyntaxKind.ClassKeyword),
identifier: context.Id.Get <SyntaxToken>(),
typeParameterList: context.TypeParameters?.Get <TypeParameterListSyntax>(),
baseList: _syntaxFactory.BaseList(SyntaxFactory.MakeToken(SyntaxKind.ColonToken), baseTypes),
constraintClauses: MakeList <TypeParameterConstraintClauseSyntax>(context._ConstraintsClauses),
openBraceToken: SyntaxFactory.MakeToken(SyntaxKind.OpenBraceToken),
members: members,
closeBraceToken: SyntaxFactory.MakeToken(SyntaxKind.CloseBraceToken),
semicolonToken: null);
_pool.Free(members);
_pool.Free(baseTypes);
if (context.Namespace != null)
{
m = AddNameSpaceToMember(context.Namespace, m);
}
else
{
m = (MemberDeclarationSyntax)CheckTypeName(context, "CLASS", m);
}
context.Put(m);
if (context.Data.Partial)
{
GlobalEntities.NeedsProcessing = true;
}
}
