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); }