public static SourcePropertyAccessorSymbol CreateAccessorSymbol(
NamedTypeSymbol containingType,
SourcePropertySymbol property,
DeclarationModifiers propertyModifiers,
string propertyName,
ArrowExpressionClauseSyntax syntax,
PropertySymbol explicitlyImplementedPropertyOpt,
string aliasQualifierOpt,
DiagnosticBag diagnostics)
{
string name;
ImmutableArray<MethodSymbol> explicitInterfaceImplementations;
GetNameAndExplicitInterfaceImplementations(
explicitlyImplementedPropertyOpt,
propertyName,
property.IsCompilationOutputWinMdObj(),
aliasQualifierOpt,
isGetMethod: true,
name: out name,
explicitInterfaceImplementations:
out explicitInterfaceImplementations);
return new SourcePropertyAccessorSymbol(
containingType,
name,
property,
propertyModifiers,
explicitInterfaceImplementations,
syntax.Expression.GetLocation(),
syntax,
diagnostics);
}
internal static bool IsInExpressionBody(
int position,
ArrowExpressionClauseSyntax expressionBodyOpt,
SyntaxToken semicolonToken)
{
return expressionBodyOpt != null
&& IsBeforeToken(position, expressionBodyOpt, semicolonToken);
}
/// <summary>
/// Creates a speculative SemanticModel for an expression body that did not appear in the original source code.
/// </summary>
internal static MethodBodySemanticModel CreateSpeculative(SyntaxTreeSemanticModel parentSemanticModel, MethodSymbol owner, ArrowExpressionClauseSyntax syntax, Binder rootBinder, int position)
{
Debug.Assert(parentSemanticModel != null);
Debug.Assert(syntax != null);
Debug.Assert(rootBinder != null);
Debug.Assert(rootBinder.IsSemanticModelBinder);
return new MethodBodySemanticModel(parentSemanticModel.Compilation, owner, rootBinder, syntax, parentSemanticModel, position);
}
public override void VisitArrowExpressionClause(ArrowExpressionClauseSyntax node)
{
if (!this.InsideFluentOrInitializerExample) return;
var syntaxNode = node?.ChildNodes()?.LastOrDefault()?.WithAdditionalAnnotations();
if (syntaxNode == null) return;
var line = node.SyntaxTree.GetLineSpan(node.Span).StartLinePosition.Line;
var walker = new CodeWithDocumentationWalker(ClassDepth, line);
walker.Visit(syntaxNode);
this.Blocks.AddRange(walker.Blocks);
}
public static PropertyDeclarationSyntax PropertyDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, TypeSyntax type, ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, SyntaxToken identifier, AccessorListSyntax accessorList, ArrowExpressionClauseSyntax expressionBody, EqualsValueClauseSyntax initializer, SyntaxToken semicolonToken)
{
return PropertyDeclaration(
attributeLists,
modifiers,
refKeyword: default(SyntaxToken),
type: type,
explicitInterfaceSpecifier: explicitInterfaceSpecifier,
identifier: identifier,
accessorList: accessorList,
expressionBody: expressionBody,
initializer: initializer,
semicolonToken: semicolonToken);
}
public static DestructorDeclarationSyntax DestructorDeclaration(
SyntaxList<AttributeListSyntax> attributeLists,
SyntaxTokenList modifiers,
SyntaxToken identifier,
ParameterListSyntax parameterList,
ArrowExpressionClauseSyntax expressionBody)
=> DestructorDeclaration(
attributeLists,
modifiers,
SyntaxFactory.Token(SyntaxKind.TildeToken),
identifier,
parameterList,
default(BlockSyntax),
expressionBody,
default(SyntaxToken));
public static ConstructorDeclarationSyntax ConstructorDeclaration(
SyntaxList<AttributeListSyntax> attributeLists,
SyntaxTokenList modifiers,
SyntaxToken identifier,
ParameterListSyntax parameterList,
ConstructorInitializerSyntax initializer,
ArrowExpressionClauseSyntax expressionBody)
=> ConstructorDeclaration(
attributeLists,
modifiers,
identifier,
parameterList,
initializer,
default(BlockSyntax),
expressionBody,
default(SyntaxToken));
public static MethodDeclarationSyntax MethodDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, TypeSyntax returnType, ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, SyntaxToken identifier, TypeParameterListSyntax typeParameterList, ParameterListSyntax parameterList, SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses, BlockSyntax body, ArrowExpressionClauseSyntax expressionBody, SyntaxToken semicolonToken)
{
return SyntaxFactory.MethodDeclaration(
attributeLists,
modifiers,
default(SyntaxToken),
returnType,
explicitInterfaceSpecifier,
identifier,
typeParameterList,
parameterList,
constraintClauses,
body,
expressionBody,
semicolonToken);
}
public static IndexerDeclarationSyntax IndexerDeclaration(
SyntaxList<AttributeListSyntax> attributeLists,
SyntaxTokenList modifiers,
TypeSyntax type,
ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier,
SyntaxToken thisKeyword,
BracketedParameterListSyntax parameterList,
AccessorListSyntax accessorList,
ArrowExpressionClauseSyntax expressionBody,
SyntaxToken semicolonToken)
{
return SyntaxFactory.IndexerDeclaration(
attributeLists: attributeLists,
modifiers: modifiers,
refKeyword: default(SyntaxToken),
type: type,
explicitInterfaceSpecifier: explicitInterfaceSpecifier,
thisKeyword: thisKeyword,
parameterList: parameterList,
accessorList: accessorList,
expressionBody: expressionBody,
semicolonToken: semicolonToken);
}
/// <summary>
/// Called when the visitor visits a ArrowExpressionClauseSyntax node.
/// </summary>
public override void VisitArrowExpressionClause(ArrowExpressionClauseSyntax node)
{
var accessor = SyntaxFactory.ReturnStatement(node.Expression);
_members.Add(accessor);
}
private SourcePropertyAccessorSymbol(
NamedTypeSymbol containingType,
string name,
SourcePropertySymbol property,
DeclarationModifiers propertyModifiers,
ImmutableArray<MethodSymbol> explicitInterfaceImplementations,
Location location,
ArrowExpressionClauseSyntax syntax,
DiagnosticBag diagnostics) :
base(containingType, syntax.GetReference(), syntax.GetReference(), location)
{
_property = property;
_explicitInterfaceImplementations = explicitInterfaceImplementations;
_name = name;
_isAutoPropertyAccessor = false;
// The modifiers for the accessor are the same as the modifiers for the property,
// minus the indexer bit
var declarationModifiers = propertyModifiers & ~DeclarationModifiers.Indexer;
// ReturnsVoid property is overridden in this class so
// returnsVoid argument to MakeFlags is ignored.
this.MakeFlags(MethodKind.PropertyGet, declarationModifiers, returnsVoid: false, isExtensionMethod: false,
isMetadataVirtualIgnoringModifiers: explicitInterfaceImplementations.Any());
CheckModifiersForBody(location, diagnostics);
var info = ModifierUtils.CheckAccessibility(this.DeclarationModifiers);
if (info != null)
{
diagnostics.Add(info, location);
}
this.CheckModifiers(location, isAutoPropertyOrExpressionBodied: true, diagnostics: diagnostics);
if (this.IsOverride)
{
MethodSymbol overriddenMethod = this.OverriddenMethod;
if ((object)overriddenMethod != null)
{
// If this accessor is overriding a method from metadata, it is possible that
// the name of the overridden method doesn't follow the C# get_X/set_X pattern.
// We should copy the name so that the runtime will recognize this as an override.
_name = overriddenMethod.Name;
}
}
}
public override void VisitArrowExpressionClause(ArrowExpressionClauseSyntax node)
{
var arrowBinder = new ExpressionVariableBinder(node, _enclosing);
AddToMap(node, arrowBinder);
Visit(node.Expression, arrowBinder);
}
public override IMethodSymbol GetDeclaredSymbol(ArrowExpressionClauseSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken))
{
// Can't define another member inside member.
return null;
}
/// <summary> /// Given a syntax node that declares an expression body, get the corresponding symbol. /// </summary> /// <param name="declarationSyntax">The syntax node that declares an expression body.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>The symbol that was declared.</returns> public abstract IMethodSymbol GetDeclaredSymbol(ArrowExpressionClauseSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken));
internal abstract bool TryGetSpeculativeSemanticModelCore(SyntaxTreeSemanticModel parentModel, int position, ArrowExpressionClauseSyntax expressionBody, out SemanticModel speculativeModel);
public static SyntaxNode TryGetEffectiveGetterBody(ArrowExpressionClauseSyntax propertyBody, AccessorListSyntax accessorList)
{
if (propertyBody != null)
{
return propertyBody.Expression;
}
return accessorList?.Accessors.Where(a => a.IsKind(SyntaxKind.GetAccessorDeclaration)).FirstOrDefault()?.Body;
}
internal override bool TryGetSpeculativeSemanticModelCore(SyntaxTreeSemanticModel parentModel, int position, ArrowExpressionClauseSyntax expressionBody, out SemanticModel speculativeModel)
{
position = CheckAndAdjustPosition(position);
var model = this.GetMemberModel(position);
if (model != null)
{
return model.TryGetSpeculativeSemanticModelCore(parentModel, position, expressionBody, out speculativeModel);
}
speculativeModel = null;
return false;
}
/// <summary>
/// Binds an expression-bodied member with expression e as either { return e;} or { e; }.
/// </summary>
public BoundBlock BindExpressionBodyAsBlock(ArrowExpressionClauseSyntax expressionBody,
DiagnosticBag diagnostics)
{
BoundExpression expression = this.BindValue(expressionBody.Expression, diagnostics, BindValueKind.RValue);
return CreateBlockFromExpression(expressionBody, this.Locals, expressionBody.Expression, expression, diagnostics);
}
internal override bool TryGetSpeculativeSemanticModelCore(SyntaxTreeSemanticModel parentModel, int position, ArrowExpressionClauseSyntax expressionBody, out SemanticModel speculativeModel)
{
speculativeModel = null;
return false;
}
public PropertyDeclarationSyntax Update(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, TypeSyntax type, ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, SyntaxToken identifier, AccessorListSyntax accessorList, ArrowExpressionClauseSyntax expressionBody, EqualsValueClauseSyntax initializer, SyntaxToken semicolonToken)
{
return Update(attributeLists, modifiers, this.RefKeyword, type, explicitInterfaceSpecifier, identifier, accessorList, expressionBody, initializer, semicolonToken);
}
internal override bool TryGetSpeculativeSemanticModelCore(SyntaxTreeSemanticModel parentModel, int position, ArrowExpressionClauseSyntax expressionBody, out SemanticModel speculativeModel)
{
position = CheckAndAdjustPosition(position);
var binder = this.GetEnclosingBinder(position);
if (binder == null)
{
speculativeModel = null;
return false;
}
var methodSymbol = (MethodSymbol)this.MemberSymbol;
binder = new ExecutableCodeBinder(expressionBody, methodSymbol, binder);
speculativeModel = CreateSpeculative(parentModel, methodSymbol, expressionBody, binder, position);
return true;
}
public MethodDeclarationSyntax Update(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, TypeSyntax returnType, ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, SyntaxToken identifier, TypeParameterListSyntax typeParameterList, ParameterListSyntax parameterList, SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses, BlockSyntax body, ArrowExpressionClauseSyntax expressionBody, SyntaxToken semicolonToken)
{
return Update(attributeLists, modifiers, this.RefKeyword, returnType, explicitInterfaceSpecifier, identifier, typeParameterList, parameterList, constraintClauses, body, expressionBody, semicolonToken);
}
public override void VisitArrowExpressionClause(ArrowExpressionClauseSyntax node)
{
base.VisitArrowExpressionClause(node);
// check for mismatch in property value expressions not matching property declaration
if (node.Parent != null && node.Parent.IsKind(SyntaxKind.PropertyDeclaration))
{
switch (node.Parent.Kind())
{
case SyntaxKind.PropertyDeclaration:
case SyntaxKind.IndexerDeclaration:
var symbol = context.SemanticModel.GetDeclaredSymbol(node.Parent);
if (symbol != null)
{
CheckAssignment(symbol, node.Expression);
}
break;
}
}
}
private IEnumerable<ITypeSymbol> InferTypeInArrowExpressionClause(ArrowExpressionClauseSyntax arrowClause)
{
if (arrowClause.IsParentKind(SyntaxKind.PropertyDeclaration))
{
return InferTypeInPropertyDeclaration(arrowClause.Parent as PropertyDeclarationSyntax);
}
if (arrowClause.Parent is BaseMethodDeclarationSyntax)
{
return InferTypeInBaseMethodDeclaration(arrowClause.Parent as BaseMethodDeclarationSyntax);
}
return SpecializedCollections.EmptyEnumerable<ITypeSymbol>();
}
public override IMethodSymbol GetDeclaredSymbol(ArrowExpressionClauseSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken))
{
CheckSyntaxNode(declarationSyntax);
var containingMemberSyntax = declarationSyntax.Parent;
NamespaceOrTypeSymbol container;
switch (containingMemberSyntax.Kind())
{
case SyntaxKind.PropertyDeclaration:
case SyntaxKind.IndexerDeclaration:
container = GetDeclaredTypeMemberContainer(containingMemberSyntax);
Debug.Assert((object)container != null);
// We are looking for the SourcePropertyAccessorSymbol here,
// not the SourcePropertySymbol, so use declarationSyntax
// to exclude the property symbol from being retrieved.
return this.GetDeclaredMember(container, declarationSyntax.Span) as MethodSymbol;
default:
// Don't throw, use only for the assert
ExceptionUtilities.UnexpectedValue(containingMemberSyntax.Kind());
return null;
}
}
private Document RewriteExpressionBodiedMemberAndIntroduceLocalDeclaration(
SemanticDocument document,
ArrowExpressionClauseSyntax arrowExpression,
ExpressionSyntax expression,
NameSyntax newLocalName,
LocalDeclarationStatementSyntax declarationStatement,
bool allOccurrences,
CancellationToken cancellationToken)
{
var oldBody = arrowExpression;
var oldParentingNode = oldBody.Parent;
var leadingTrivia = oldBody.GetLeadingTrivia()
.AddRange(oldBody.ArrowToken.TrailingTrivia);
var newStatement = Rewrite(document, expression, newLocalName, document, oldBody.Expression, allOccurrences, cancellationToken);
var newBody = SyntaxFactory.Block(declarationStatement, SyntaxFactory.ReturnStatement(newStatement))
.WithLeadingTrivia(leadingTrivia)
.WithTrailingTrivia(oldBody.GetTrailingTrivia())
.WithAdditionalAnnotations(Formatter.Annotation);
SyntaxNode newParentingNode = null;
if (oldParentingNode is BasePropertyDeclarationSyntax)
{
var getAccessor = SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration, newBody);
var accessorList = SyntaxFactory.AccessorList(SyntaxFactory.List(new[] { getAccessor }));
newParentingNode = ((BasePropertyDeclarationSyntax)oldParentingNode).RemoveNode(oldBody, SyntaxRemoveOptions.KeepNoTrivia);
if (newParentingNode.IsKind(SyntaxKind.PropertyDeclaration))
{
var propertyDeclaration = ((PropertyDeclarationSyntax)newParentingNode);
newParentingNode = propertyDeclaration
.WithAccessorList(accessorList)
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.None))
.WithTrailingTrivia(propertyDeclaration.SemicolonToken.TrailingTrivia);
}
else if (newParentingNode.IsKind(SyntaxKind.IndexerDeclaration))
{
var indexerDeclaration = ((IndexerDeclarationSyntax)newParentingNode);
newParentingNode = indexerDeclaration
.WithAccessorList(accessorList)
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.None))
.WithTrailingTrivia(indexerDeclaration.SemicolonToken.TrailingTrivia);
}
}
else if (oldParentingNode is BaseMethodDeclarationSyntax)
{
newParentingNode = ((BaseMethodDeclarationSyntax)oldParentingNode)
.RemoveNode(oldBody, SyntaxRemoveOptions.KeepNoTrivia)
.WithBody(newBody);
if (newParentingNode.IsKind(SyntaxKind.MethodDeclaration))
{
var methodDeclaration = ((MethodDeclarationSyntax)newParentingNode);
newParentingNode = methodDeclaration
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.None))
.WithTrailingTrivia(methodDeclaration.SemicolonToken.TrailingTrivia);
}
else if (newParentingNode.IsKind(SyntaxKind.OperatorDeclaration))
{
var operatorDeclaration = ((OperatorDeclarationSyntax)newParentingNode);
newParentingNode = operatorDeclaration
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.None))
.WithTrailingTrivia(operatorDeclaration.SemicolonToken.TrailingTrivia);
}
else if (newParentingNode.IsKind(SyntaxKind.ConversionOperatorDeclaration))
{
var conversionOperatorDeclaration = ((ConversionOperatorDeclarationSyntax)newParentingNode);
newParentingNode = conversionOperatorDeclaration
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.None))
.WithTrailingTrivia(conversionOperatorDeclaration.SemicolonToken.TrailingTrivia);
}
}
var newRoot = document.Root.ReplaceNode(oldParentingNode, newParentingNode);
return document.Document.WithSyntaxRoot(newRoot);
}
public override void VisitArrowExpressionClause(ArrowExpressionClauseSyntax node)
{
// Do nothing, expressions do not need special binders.
}
/// <summary>
/// Binds an expression-bodied member with expression e as either { return e;} or { e; }.
/// </summary>
internal BoundBlock BindExpressionBodyAsBlock(ArrowExpressionClauseSyntax expressionBody,
DiagnosticBag diagnostics)
{
Binder bodyBinder = this.GetBinder(expressionBody);
Debug.Assert(bodyBinder != null);
RefKind refKind = RefKind.None;
ExpressionSyntax expressionSyntax = expressionBody.Expression.SkipRef(out refKind);
BoundExpression expression = bodyBinder.BindValue(expressionSyntax, diagnostics, refKind != RefKind.None ? BindValueKind.RefReturn : BindValueKind.RValue);
return bodyBinder.CreateBlockFromExpression(expressionBody, bodyBinder.GetDeclaredLocalsForScope(expressionBody), refKind, expression, expressionSyntax, diagnostics);
}
public static DestructorDeclarationSyntax DestructorDeclaration(
SyntaxList<AttributeListSyntax> attributeLists,
SyntaxTokenList modifiers,
SyntaxToken tildeToken,
SyntaxToken identifier,
ParameterListSyntax parameterList,
ArrowExpressionClauseSyntax expressionBody,
SyntaxToken semicolonToken)
=> DestructorDeclaration(
attributeLists,
modifiers,
tildeToken,
identifier,
parameterList,
default(BlockSyntax),
expressionBody,
semicolonToken);
/// <summary>
/// Get a SemanticModel object that is associated with an expression body that did not appear in
/// this source code. This can be used to get detailed semantic information about sub-parts
/// of an expression body that did not appear in source code.
/// </summary>
/// <param name="position">A character position used to identify a declaration scope and accessibility. This
/// character position must be within the FullSpan of the Root syntax node in this SemanticModel.
/// </param>
/// <param name="expressionBody">A syntax node that represents a parsed expression body. This node should not be
/// present in the syntax tree associated with this object.</param>
/// <param name="speculativeModel">A SemanticModel object that can be used to inquire about the semantic
/// information associated with syntax nodes within <paramref name="expressionBody"/>.</param>
/// <returns>Flag indicating whether a speculative semantic model was created.</returns>
/// <exception cref="ArgumentException">Throws this exception if the <paramref name="expressionBody"/> node is contained any SyntaxTree in the current Compilation.</exception>
/// <exception cref="ArgumentNullException">Throws this exception if <paramref name="expressionBody"/> is null.</exception>
/// <exception cref="InvalidOperationException">Throws this exception if this model is a speculative semantic model, i.e. <see cref="SemanticModel.IsSpeculativeSemanticModel"/> is true.
/// Chaining of speculative semantic model is not supported.</exception>
public bool TryGetSpeculativeSemanticModel(int position, ArrowExpressionClauseSyntax expressionBody, out SemanticModel speculativeModel)
{
CheckModelAndSyntaxNodeToSpeculate(expressionBody);
return TryGetSpeculativeSemanticModelCore((SyntaxTreeSemanticModel)this, position, expressionBody, out speculativeModel);
}
