protected SourceEnumConstantSymbol(SourceMemberContainerTypeSymbol containingEnum, EnumMemberDeclarationSyntax syntax, DiagnosticBag diagnostics)
: base(containingEnum, syntax.Identifier.ValueText, syntax.GetReference(), syntax.Identifier.GetLocation())
{
if (this.Name == WellKnownMemberNames.EnumBackingFieldName)
{
diagnostics.Add(ErrorCode.ERR_ReservedEnumerator, this.Location, WellKnownMemberNames.EnumBackingFieldName);
}
}
public static SourceEnumConstantSymbol CreateExplicitValuedConstant(
SourceMemberContainerTypeSymbol containingEnum,
EnumMemberDeclarationSyntax syntax,
DiagnosticBag diagnostics)
{
var initializer = syntax.EqualsValue;
Debug.Assert(initializer != null);
return new ExplicitValuedEnumConstantSymbol(containingEnum, syntax, initializer, diagnostics);
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclarationSyntax node)
{
var symbol = model.GetDeclaredSymbol(node);
this.declaredItems.Add(new DeclaredItemDocument
{
Name = symbol.Name,
Location = this.model.SyntaxTree.GetLineSpan(node.Span, false).StartLinePosition.Line,
Identifier = symbol.ToDisplayString(),
Type = "EnumMember"
});
base.VisitEnumMemberDeclaration(node);
}
public static SourceEnumConstantSymbol CreateImplicitValuedConstant(
SourceMemberContainerTypeSymbol containingEnum,
EnumMemberDeclarationSyntax syntax,
SourceEnumConstantSymbol otherConstant,
int otherConstantOffset,
DiagnosticBag diagnostics)
{
if ((object)otherConstant == null)
{
Debug.Assert(otherConstantOffset == 0);
return new ZeroValuedEnumConstantSymbol(containingEnum, syntax, diagnostics);
}
else
{
Debug.Assert(otherConstantOffset > 0);
return new ImplicitValuedEnumConstantSymbol(containingEnum, syntax, otherConstant, (uint)otherConstantOffset, diagnostics);
}
}
public override SyntaxNode VisitEnumMemberDeclaration(EnumMemberDeclarationSyntax node)
{
if (node.EqualsValue == null)
{
lastValue++;
return node.WithEqualsValue(Syntax.EqualsValueClause(Syntax.Token(SyntaxKind.EqualsToken),
Syntax.LiteralExpression(SyntaxKind.NumericLiteralExpression, Syntax.Literal(lastValue))
));
}
else
{
ExpressionSyntax expr = node.EqualsValue.Value;
if (expr.Kind == SyntaxKind.NumericLiteralExpression)
{
lastValue = int.Parse(expr.ToString());
return node;
}
throw new NotImplementedException("enum with non-literal explicit value");
}
return base.VisitEnumMemberDeclaration(node);
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclarationSyntax node)
{
AsChild(node, node.Identifier.Text, node.Identifier.GetLocation(), node.AttributeLists.Span);
}
/// <summary>
/// Given a enum member declaration, get the corresponding field symbol.
/// </summary>
/// <param name="declarationSyntax">The syntax node that declares an enum member.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The symbol that was declared.</returns>
public override IFieldSymbol GetDeclaredSymbol(EnumMemberDeclarationSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken))
{
return (IFieldSymbol)GetDeclaredMemberSymbol(declarationSyntax);
}
private void ClassifyUpdate(EnumMemberDeclarationSyntax oldNode, EnumMemberDeclarationSyntax newNode)
{
if (!SyntaxFactory.AreEquivalent(oldNode.Identifier, newNode.Identifier))
{
ReportError(RudeEditKind.Renamed);
return;
}
Debug.Assert(!SyntaxFactory.AreEquivalent(oldNode.EqualsValue, newNode.EqualsValue));
ReportError(RudeEditKind.InitializerUpdate);
}
/// <summary> /// Given a enum member declaration, get the corresponding field symbol. /// </summary> /// <param name="declarationSyntax">The syntax node that declares an enum member.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>The symbol that was declared.</returns> public abstract IFieldSymbol GetDeclaredSymbol(EnumMemberDeclarationSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken));
public override IFieldSymbol GetDeclaredSymbol(EnumMemberDeclarationSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken))
{
// Can't define member inside member.
return null;
}
public static void AnalyzeEnumDeclaration(SyntaxNodeAnalysisContext context)
{
var enumDeclaration = (EnumDeclarationSyntax)context.Node;
SeparatedSyntaxList <EnumMemberDeclarationSyntax> members = enumDeclaration.Members;
int count = members.Count;
if (count <= 1)
{
return;
}
SyntaxTree tree = context.Node.SyntaxTree;
bool?isPrevSingleLine = null;
for (int i = 1; i < count; i++)
{
SyntaxToken commaToken = members.GetSeparator(i - 1);
SyntaxTriviaList trailingTrivia = commaToken.TrailingTrivia;
SyntaxTrivia lastTrailingTrivia = trailingTrivia.LastOrDefault();
if (!lastTrailingTrivia.IsKind(SyntaxKind.EndOfLineTrivia))
{
isPrevSingleLine = false;
continue;
}
EnumMemberDeclarationSyntax 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(TextSpan.FromBounds(members[i - 1].SpanStart, commaToken.Span.End), 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(commaToken.Span.End, end), context.CancellationToken) == 2)
{
DiagnosticHelpers.ReportDiagnostic(context,
DiagnosticDescriptors.AddEmptyLineBetweenDeclarations,
lastTrailingTrivia);
}
}
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclarationSyntax node)
{
CheckXmlDocForErrors(node, semanticModel.GetDeclaredSymbol(node));
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclarationSyntax node)
{
LogicalLineCount++;
base.VisitEnumMemberDeclaration(node);
}
public ExplicitValuedEnumConstantSymbol(
SourceMemberContainerTypeSymbol containingEnum,
EnumMemberDeclarationSyntax syntax,
EqualsValueClauseSyntax initializer,
DiagnosticBag diagnostics) :
base(containingEnum, syntax, diagnostics)
{
this.equalsValueNodeRef = initializer.GetReference();
}
// 枚举成员
public virtual void VisitEnumMemberDeclarationSyntax(EnumMemberDeclarationSyntax value)
{
DefaultVisit(value);
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclarationSyntax node)
{
AsChild(node, node.Identifier.Text, node.Identifier.GetLocation());
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclarationSyntax node)
{
InsertLLOCMap(node.GetLocation());
base.VisitEnumMemberDeclaration(node);
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclarationSyntax node)
{
WriteLine($"{node.Identifier}{node.EqualsValue},");
}
// // Summary: // Called when the visitor visits a EnumMemberDeclarationSyntax node. public virtual void VisitEnumMemberDeclaration(EnumMemberDeclarationSyntax node);
private static async Task <Document> DeclareExplicitValueAsync(
Document document,
EnumDeclarationSyntax enumDeclaration,
INamedTypeSymbol enumSymbol,
bool isFlags,
bool useBitShift,
ImmutableArray <ulong> values,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
List <ulong> reservedValues = values.ToList();
SeparatedSyntaxList <EnumMemberDeclarationSyntax> members = enumDeclaration.Members;
SeparatedSyntaxList <EnumMemberDeclarationSyntax> newMembers = members;
for (int i = 0; i < members.Count; i++)
{
if (members[i].EqualsValue == null)
{
IFieldSymbol fieldSymbol = semanticModel.GetDeclaredSymbol(members[i], cancellationToken);
ulong?value = null;
if (isFlags)
{
Optional <ulong> optional = FlagsUtility <ulong> .Instance.GetUniquePowerOfTwo(reservedValues);
if (optional.HasValue &&
ConvertHelpers.CanConvertFromUInt64(optional.Value, enumSymbol.EnumUnderlyingType.SpecialType))
{
value = optional.Value;
}
}
else
{
value = SymbolUtility.GetEnumValueAsUInt64(fieldSymbol.ConstantValue, enumSymbol);
}
if (value != null)
{
reservedValues.Add(value.Value);
ExpressionSyntax expression;
if (useBitShift &&
value.Value > 1)
{
var power = (int)Math.Log(Convert.ToDouble(value.Value), 2);
expression = LeftShiftExpression(NumericLiteralExpression(1), NumericLiteralExpression(power));
}
else
{
expression = NumericLiteralExpression(value.Value, enumSymbol.EnumUnderlyingType.SpecialType);
}
EnumMemberDeclarationSyntax newMember = members[i].Update(
members[i].AttributeLists,
members[i].Modifiers,
members[i].Identifier.WithoutTrailingTrivia(),
EqualsValueClause(expression).WithTrailingTrivia(members[i].Identifier.TrailingTrivia));
newMembers = newMembers.ReplaceAt(i, newMember);
}
}
}
EnumDeclarationSyntax newEnumDeclaration = enumDeclaration.WithMembers(newMembers);
return(await document.ReplaceNodeAsync(enumDeclaration, newEnumDeclaration, cancellationToken).ConfigureAwait(false));
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclarationSyntax node)
{
base.VisitEnumMemberDeclaration(node);
Append(node);
}
public ZeroValuedEnumConstantSymbol(
SourceMemberContainerTypeSymbol containingEnum,
EnumMemberDeclarationSyntax syntax,
DiagnosticBag diagnostics)
: base(containingEnum, syntax, diagnostics)
{
}
/// <summary>
/// Given a enum member declaration, get the corresponding field symbol.
/// </summary>
/// <param name="declarationSyntax">The syntax node that declares an enum member.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The symbol that was declared.</returns>
public override IFieldSymbol GetDeclaredSymbol(EnumMemberDeclarationSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken))
{
using (Logger.LogBlock(FunctionId.CSharp_SemanticModel_GetDeclaredSymbol, message: this.SyntaxTree.FilePath, cancellationToken: cancellationToken))
{
return (IFieldSymbol)GetDeclaredMemberSymbol(declarationSyntax);
}
}
public ImplicitValuedEnumConstantSymbol(
SourceMemberContainerTypeSymbol containingEnum,
EnumMemberDeclarationSyntax syntax,
SourceEnumConstantSymbol otherConstant,
uint otherConstantOffset,
DiagnosticBag diagnostics) :
base(containingEnum, syntax, diagnostics)
{
Debug.Assert((object)otherConstant != null);
Debug.Assert(otherConstantOffset > 0);
this.otherConstant = otherConstant;
this.otherConstantOffset = otherConstantOffset;
}
public EnumMemberDeclarationTranslation(EnumMemberDeclarationSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
}
public void VisitEnumMemberDeclaration(EnumMemberDeclarationSyntax node)
{
if (node == null)
throw new ArgumentNullException("node");
node.Validate();
WriteLeadingTrivia(node);
_writer.WriteIndent();
WriteAttributes(
node,
_writer.Configuration.LineBreaksAndWrapping.Other.PlaceFieldAttributeOnSameLine
);
_writer.WriteIdentifier(node.Identifier);
if (node.EqualsValue != null)
node.EqualsValue.Accept(this);
var parent = node.Parent as EnumDeclarationSyntax;
if (
parent == null ||
parent.Members.IndexOf(node) < parent.Members.Count - 1
)
_writer.WriteSyntax(Syntax.Comma);
_writer.WriteLine();
WriteTrailingTrivia(node);
}
public static string EnumMemberDeclaration(EnumMemberDeclarationSyntax declaration)
{
var output = declaration.Identifier.Text;
if (declaration.EqualsValue != null)
{
output += " " + SyntaxNode(declaration.EqualsValue);
}
return output;
}
public override SyntaxNode VisitEnumMemberDeclaration(EnumMemberDeclarationSyntax node)
{
if (node == null)
return null;
var symbol = m_model.GetDeclaredSymbol(node);
node = (EnumMemberDeclarationSyntax)base.VisitEnumMemberDeclaration(node);
if (!IsPrivateOrInternal(symbol.DeclaredAccessibility))
node = (EnumMemberDeclarationSyntax)ApplyDocComment(node, symbol.GetDocumentationCommentId());
return node;
}
public void Add(EnumMemberDeclarationSyntax node)
{
/* // Summary:
// Gets the attribute declaration list.
public SyntaxList<AttributeListSyntax> AttributeLists { get; }
public EqualsValueClauseSyntax EqualsValue { get; }
//
// Summary:
// Gets the identifier.
public SyntaxToken Identifier { get; }
*/
// add field info
TypeExtraInfo tei = Chunk.AddTypeExtraInfo(this.Class,Model);
tei.AddEnumMember(node.Identifier.ToString(), node.EqualsValue != null ? node.EqualsValue.Value : null);
/*
// Summary:
// Gets the attribute declaration list.
public override SyntaxList<AttributeListSyntax> AttributeLists { get; }
public override VariableDeclarationSyntax Declaration { get; }
//
// Summary:
// Gets the modifier list.
public override SyntaxTokenList Modifiers { get; }
public override SyntaxToken SemicolonToken { get; }
*/
// add to metadata for runtime type building
FlatArrayBuilder fab = new FlatArrayBuilder();
fab.Add(FlatValue.Int32((int)ClassMemberType.StaticField));
//TypeInfo ti = Chunk.Model.GetTypeInfo(node..Type);
fab.Add(FlatValue.String(Class.GetFullyQualifiedName()));
{
FlatArrayBuilder varList = new FlatArrayBuilder();
varList.Add(FlatValue.String(node.Identifier.ToString()));
fab.Add(varList.GetFlatValue());
}
{
FlatArrayBuilder valueList = new FlatArrayBuilder();
if (node.EqualsValue != null)
{
if (node.EqualsValue.Value.Kind == SyntaxKind.NumericLiteralExpression)
{
valueList.Add(FlatValue.Int32(int.Parse(node.EqualsValue.Value.ToString())));
}
else
{
throw new NotImplementedException("Enum member without numeric literal expression");
}
}
else
{
throw new NotImplementedException("Enum member without numeric literal expression");
}
fab.Add(valueList.GetFlatValue());
}
Members.Add(fab.GetFlatValue());
}
public override void VisitEnumMemberDeclaration (EnumMemberDeclarationSyntax node)
{
base.VisitEnumMemberDeclaration (node);
Append (node);
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclarationSyntax node)
{
WriteLine($"{node.Identifier}{node.EqualsValue},");
}
private string GetVariablePrototype(EnumMemberDeclarationSyntax node, IFieldSymbol symbol, PrototypeFlags flags)
{
if ((flags & PrototypeFlags.Signature) != 0)
{
if (flags != PrototypeFlags.Signature)
{
// vsCMPrototypeUniqueSignature can't be combined with anything else.
throw Exceptions.ThrowEInvalidArg();
}
// The unique signature is simply the node key.
return GetNodeKey(node).Name;
}
var builder = new StringBuilder();
AppendVariablePrototype(builder, symbol, flags, GetName(node));
if ((flags & PrototypeFlags.Initializer) != 0 &&
node.EqualsValue != null &&
node.EqualsValue.Value != null &&
!node.EqualsValue.Value.IsMissing)
{
builder.Append(" = ");
builder.Append(node.EqualsValue.Value);
}
return builder.ToString();
}
/// <summary>
/// Traverse AST node that represents enumeration constant declaration
/// </summary>
/// <param name="node">AST node.</param>
public override void VisitEnumMemberDeclaration(EnumMemberDeclarationSyntax node)
{
try
{
if (!node.Identifier.Span.IsEmpty)
{
var symbol = _sm.GetDeclaredSymbol(node);
if (!_defined.Contains(symbol))
{
_defined.Add(symbol);
var def = Def.For(symbol: symbol, type: "enum field", name: symbol.Name).At(_path, node.Identifier.Span);
def.Exported = true;
AddDef(def);
}
}
base.VisitEnumMemberDeclaration(node);
}
catch (Exception e)
{
}
}
private VirtualTreePoint GetStartPoint(SourceText text, EnumMemberDeclarationSyntax node, EnvDTE.vsCMPart part)
{
int startPosition;
switch (part)
{
case EnvDTE.vsCMPart.vsCMPartName:
case EnvDTE.vsCMPart.vsCMPartAttributes:
case EnvDTE.vsCMPart.vsCMPartHeader:
case EnvDTE.vsCMPart.vsCMPartWhole:
case EnvDTE.vsCMPart.vsCMPartBodyWithDelimiter:
case EnvDTE.vsCMPart.vsCMPartHeaderWithAttributes:
throw Exceptions.ThrowENotImpl();
case EnvDTE.vsCMPart.vsCMPartAttributesWithDelimiter:
if (node.AttributeLists.Count == 0)
{
throw Exceptions.ThrowEFail();
}
goto case EnvDTE.vsCMPart.vsCMPartWholeWithAttributes;
case EnvDTE.vsCMPart.vsCMPartWholeWithAttributes:
startPosition = node.SpanStart;
break;
case EnvDTE.vsCMPart.vsCMPartBody:
throw Exceptions.ThrowEFail();
case EnvDTE.vsCMPart.vsCMPartNavigate:
startPosition = node.Identifier.SpanStart;
break;
default:
throw Exceptions.ThrowEInvalidArg();
}
return new VirtualTreePoint(node.SyntaxTree, text, startPosition);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override void VisitEnumMemberDeclaration(EnumMemberDeclarationSyntax node)
{
var enumMemberTranslationUnit = new EnumMemberTranslationUnitFactory(node, this.semanticModel).Create();
this.enumDeclaration.AddMember(enumMemberTranslationUnit);
this.InvokeEnumMemberVisited(this, new WalkerEventArgs());
}
public override SyntaxNode VisitEnumMemberDeclaration(EnumMemberDeclarationSyntax node)
{
_output.Write(node.Identifier, node.Identifier.ValueText);
_output.TrivialWrite(": ");
var info = _semanticModel.GetDeclaredSymbol(node);
string val;
bool hasAttr = info.GetEnumValue(out val);
if (node.EqualsValue != null)
{
if (hasAttr)
{
this.AppendCompileIssue(node, IssueType.Error, IssueId.EnumFieldTwoValue);
}
else
{
Visit(node.EqualsValue.Value);
}
}
else
{
if (hasAttr)
{
_output.Write(node, val);
}
else
{
this.AppendCompileIssue(node, IssueType.Error, IssueId.EnumFieldNoValue, node);
}
}
return node;
}
/// <summary>
/// Initializes a new instance of the <see cref="EnumMemberDeclaration"/> class.
/// </summary>
/// <param name="enumMemberDeclarationNode"></param>
public EnumMemberDeclaration(EnumMemberDeclarationSyntax enumMemberDeclarationNode)
: this(enumMemberDeclarationNode, null)
{
}
private bool CompareEnumMemberDeclarations(
EnumMemberDeclarationSyntax oldEnumMember,
EnumMemberDeclarationSyntax newEnumMember,
SyntaxNode newNodeParent,
CodeModelEventQueue eventQueue)
{
Debug.Assert(oldEnumMember != null && newEnumMember != null);
bool same = true;
if (!StringComparer.Ordinal.Equals(CodeModelService.GetName(oldEnumMember), CodeModelService.GetName(newEnumMember)))
{
EnqueueChangeEvent(newEnumMember, newNodeParent, CodeModelEventType.Rename, eventQueue);
same = false;
}
same &= CompareChildren(
CompareAttributeLists,
oldEnumMember.AttributeLists.AsReadOnlyList(),
newEnumMember.AttributeLists.AsReadOnlyList(),
newEnumMember,
CodeModelEventType.Unknown,
eventQueue);
return same;
}
/// <summary>
/// Initializes a new instance of the <see cref="EnumMemberDeclaration"/> class.
/// </summary>
/// <param name="enumMemberDeclarationNode"></param>
/// <param name="semanticModel"></param>
public EnumMemberDeclaration(EnumMemberDeclarationSyntax enumMemberDeclarationNode, SemanticModel semanticModel)
: base(enumMemberDeclarationNode, semanticModel)
{
}
private Document Delete(Document document, EnumMemberDeclarationSyntax node)
{
var enumDeclaration = (EnumDeclarationSyntax)node.Parent;
var members = enumDeclaration.Members;
var newMembers = members.Remove(node);
var newEnumDeclaration = enumDeclaration.WithMembers(newMembers);
// If we're removing the last enum member, we may need to move any trailing trivia
// to the enum member that comes before it.
var memberIndex = members.IndexOf(node);
if (memberIndex == members.Count - 1 && newMembers.Count > 0)
{
var trailingTrivia = node.GetTrailingTrivia();
var lastMember = newEnumDeclaration.Members.Last();
newEnumDeclaration = newEnumDeclaration.ReplaceNode(lastMember, lastMember.WithTrailingTrivia(trailingTrivia));
}
return document.ReplaceNodeAsync(enumDeclaration, newEnumDeclaration, CancellationToken.None)
.WaitAndGetResult_CodeModel(CancellationToken.None);
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclarationSyntax node)
{
throw new NotSupportedException();
}