public override VisualBasicSyntaxNode VisitDelegateDeclaration(CSS.DelegateDeclarationSyntax node) { var id = SyntaxFactory.Identifier(node.Identifier.ValueText, SyntaxFacts.IsKeywordKind(node.Identifier.Kind()), node.Identifier.GetIdentifierText(), TypeCharacter.None); var methodInfo = semanticModel.GetDeclaredSymbol(node) as INamedTypeSymbol; if (methodInfo.DelegateInvokeMethod.GetReturnType()?.SpecialType == SpecialType.System_Void) { return(SyntaxFactory.DelegateSubStatement( SyntaxFactory.List(node.AttributeLists.Select(a => (AttributeListSyntax)a.Accept(this))), ConvertModifiers(node.Modifiers), id, (TypeParameterListSyntax)node.TypeParameterList?.Accept(this), (ParameterListSyntax)node.ParameterList?.Accept(this), null )); } else { return(SyntaxFactory.DelegateFunctionStatement( SyntaxFactory.List(node.AttributeLists.Select(a => (AttributeListSyntax)a.Accept(this))), ConvertModifiers(node.Modifiers), id, (TypeParameterListSyntax)node.TypeParameterList?.Accept(this), (ParameterListSyntax)node.ParameterList?.Accept(this), SyntaxFactory.SimpleAsClause((TypeSyntax)node.ReturnType.Accept(this)) )); } }
public override SyntaxNode VisitDelegateDeclaration(DelegateDeclarationSyntax node) { if (node == null) return null; var symbol = _semanticModel.GetDeclaredSymbol(node); node = (DelegateDeclarationSyntax)base.VisitDelegateDeclaration(node); if (!IsPrivateOrInternal(symbol.DeclaredAccessibility)) node = (DelegateDeclarationSyntax)ApplyDocComment(node, symbol.GetDocumentationCommentId()); return node; }
protected SourceDelegateMethodSymbol( SourceMemberContainerTypeSymbol delegateType, TypeSymbol returnType, DelegateDeclarationSyntax syntax, MethodKind methodKind, DeclarationModifiers declarationModifiers) : base(delegateType, syntax.GetReference(), bodySyntaxReferenceOpt: null, location: syntax.Identifier.GetLocation()) { _returnType = returnType; this.MakeFlags(methodKind, declarationModifiers, _returnType.SpecialType == SpecialType.System_Void, isExtensionMethod: false); }
private NamedTypeSymbol GetDeclaredType(DelegateDeclarationSyntax declarationSyntax) { Debug.Assert(declarationSyntax != null); var name = declarationSyntax.Identifier.ValueText; return GetDeclaredNamedType(declarationSyntax, name); }
private static bool IsNestedType(DelegateDeclarationSyntax delegateDeclaration) { return delegateDeclaration?.Parent is BaseTypeDeclarationSyntax; }
public override SyntaxNode VisitDelegateDeclaration(DelegateDeclarationSyntax node) { return VisitMemberDeclaration(node, base.VisitDelegateDeclaration(node)); }
public override INamedTypeSymbol GetDeclaredSymbol(DelegateDeclarationSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken)) { // Can't define type inside a member. return null; }
private VirtualTreePoint GetStartPoint(SourceText text, DelegateDeclarationSyntax 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.GetFirstToken().SpanStart; break; case EnvDTE.vsCMPart.vsCMPartNavigate: startPosition = node.Identifier.SpanStart; break; case EnvDTE.vsCMPart.vsCMPartBody: throw Exceptions.ThrowEFail(); default: throw Exceptions.ThrowEInvalidArg(); } return new VirtualTreePoint(node.SyntaxTree, text, startPosition); }
private string GetDelegatePrototype(DelegateDeclarationSyntax node, INamedTypeSymbol 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(); AppendDelegatePrototype(builder, symbol, flags, GetName(node)); return builder.ToString(); }
internal static void AddDelegateMembers( SourceMemberContainerTypeSymbol delegateType, ArrayBuilder<Symbol> symbols, DelegateDeclarationSyntax syntax, DiagnosticBag diagnostics) { Binder binder = delegateType.GetBinder(syntax.ParameterList); TypeSymbol returnType = binder.BindType(syntax.ReturnType, diagnostics); // reuse types to avoid reporting duplicate errors if missing: var voidType = binder.GetSpecialType(SpecialType.System_Void, diagnostics, syntax); var objectType = binder.GetSpecialType(SpecialType.System_Object, diagnostics, syntax); var intPtrType = binder.GetSpecialType(SpecialType.System_IntPtr, diagnostics, syntax); if (returnType.IsRestrictedType()) { // Method or delegate cannot return type '{0}' diagnostics.Add(ErrorCode.ERR_MethodReturnCantBeRefAny, syntax.ReturnType.Location, returnType); } // A delegate has the following members: (see CLI spec 13.6) // (1) a method named Invoke with the specified signature var invoke = new InvokeMethod(delegateType, returnType, syntax, binder, diagnostics); invoke.CheckDelegateVarianceSafety(diagnostics); symbols.Add(invoke); // (2) a constructor with argument types (object, System.IntPtr) symbols.Add(new Constructor(delegateType, voidType, objectType, intPtrType, syntax)); if (binder.Compilation.GetSpecialType(SpecialType.System_IAsyncResult).TypeKind != TypeKind.Error && binder.Compilation.GetSpecialType(SpecialType.System_AsyncCallback).TypeKind != TypeKind.Error && // WinRT delegates don't have Begin/EndInvoke methods !delegateType.IsCompilationOutputWinMdObj()) { var iAsyncResultType = binder.GetSpecialType(SpecialType.System_IAsyncResult, diagnostics, syntax); var asyncCallbackType = binder.GetSpecialType(SpecialType.System_AsyncCallback, diagnostics, syntax); // (3) BeginInvoke symbols.Add(new BeginInvokeMethod(invoke, iAsyncResultType, objectType, asyncCallbackType, syntax)); // and (4) EndInvoke methods symbols.Add(new EndInvokeMethod(invoke, iAsyncResultType, syntax)); } if (delegateType.DeclaredAccessibility <= Accessibility.Private) { return; } HashSet<DiagnosticInfo> useSiteDiagnostics = null; if (!delegateType.IsNoMoreVisibleThan(invoke.ReturnType, ref useSiteDiagnostics)) { // Inconsistent accessibility: return type '{1}' is less accessible than delegate '{0}' diagnostics.Add(ErrorCode.ERR_BadVisDelegateReturn, delegateType.Locations[0], delegateType, invoke.ReturnType); } foreach (var parameter in invoke.Parameters) { if (!parameter.Type.IsAtLeastAsVisibleAs(delegateType, ref useSiteDiagnostics)) { // Inconsistent accessibility: parameter type '{1}' is less accessible than delegate '{0}' diagnostics.Add(ErrorCode.ERR_BadVisDelegateParam, delegateType.Locations[0], delegateType, parameter.Type); } } diagnostics.Add(delegateType.Locations[0], useSiteDiagnostics); }
/// <summary> /// Creates a field declaration that stores <paramref name="methodDelegate" />. /// </summary> /// <param name="methodDelegate">The delegate the field should be created for.</param> private FieldDeclarationSyntax CreateField(DelegateDeclarationSyntax methodDelegate) { return SyntaxBuilder.Field(GetFieldName(), methodDelegate.Identifier.ValueText, Visibility.Private, _browsableAttribute, _compilerGeneratedAttribute).AsSingleLine(); }
/// <summary> /// Get a source type symbol for the given declaration syntax. /// </summary> /// <returns>Null if there is no matching declaration.</returns> internal SourceNamedTypeSymbol GetSourceTypeMember(DelegateDeclarationSyntax syntax) { return GetSourceTypeMember(syntax.Identifier.ValueText, syntax.Arity, syntax.Kind(), syntax); }
/// <summary> /// Given a delegate declaration, get the corresponding type symbol. /// </summary> /// <param name="declarationSyntax">The syntax node that declares a delegate.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>The type symbol that was declared.</returns> public override INamedTypeSymbol GetDeclaredSymbol(DelegateDeclarationSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken)) { using (Logger.LogBlock(FunctionId.CSharp_SemanticModel_GetDeclaredSymbol, message: this.SyntaxTree.FilePath, cancellationToken: cancellationToken)) { CheckSyntaxNode(declarationSyntax); return GetDeclaredType(declarationSyntax); } }
public override void VisitDelegateDeclaration(DelegateDeclarationSyntax node) { if (compilation != null) { var type = compilation.GetSemanticModel(node.SyntaxTree).GetDeclaredSymbol(node); types.Add(type); } delegateDeclarations.Add(node); base.VisitDelegateDeclaration(node); }
public override void VisitDelegateDeclaration(DelegateDeclarationSyntax node) { LS2IL.TypeExtraInfo.ClassMetadataGenerator wasClass = CurrentClass; INamedTypeSymbol s = Model.GetDeclaredSymbol(node); //System.Console.WriteLine(s.GetFullyQualifiedName()); TypeExtraInfo tei = Chunk.AddTypeExtraInfo(s, Model, IsLibrary); CurrentClass = tei.MetadataGenerator; base.VisitDelegateDeclaration(node); CurrentClass = wasClass; }
public override void VisitDelegateDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax node) { base.VisitDelegateDeclaration(node); Colorize(node.Identifier, delegateTypeColor); }
/// <summary> /// /// </summary> /// <param name="node"></param> public override sealed void VisitDelegateDeclaration(DelegateDeclarationSyntax node) { this.OnNodeVisited(node, this.type.IsInstanceOfType(node)); base.VisitDelegateDeclaration(node); }
internal static bool IsInDelegateDeclaration(int position, DelegateDeclarationSyntax delegateDecl) { Debug.Assert(delegateDecl != null); return(IsBeforeToken(position, delegateDecl, delegateDecl.SemicolonToken)); }
public override void VisitDelegateDeclaration(DelegateDeclarationSyntax node) { CheckXmlDocForErrors(node, semanticModel.GetDeclaredSymbol(node)); }
internal static bool IsInDelegateDeclaration(int position, DelegateDeclarationSyntax delegateDecl) { Debug.Assert(delegateDecl != null); return IsBeforeToken(position, delegateDecl, delegateDecl.SemicolonToken); }
/// <summary> /// Given a delegate declaration, get the corresponding type symbol. /// </summary> /// <param name="declarationSyntax">The syntax node that declares a delegate.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>The type symbol that was declared.</returns> public abstract INamedTypeSymbol GetDeclaredSymbol(DelegateDeclarationSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken));
public override void VisitDelegateDeclaration (DelegateDeclarationSyntax node) { base.VisitDelegateDeclaration (node); Append (node); }
private static void CheckDelegateVariance(DelegateDeclarationSyntax declaration, SyntaxNodeAnalysisContext context) { var declaredSymbol = context.SemanticModel.GetDeclaredSymbol(declaration); if (declaredSymbol == null) { return; } var returnType = context.SemanticModel.GetTypeInfo(declaration.ReturnType).Type; if (returnType == null) { return; } var parameterSymbols = declaration.ParameterList == null ? ImmutableArray<IParameterSymbol>.Empty : declaration.ParameterList.Parameters .Select(p => context.SemanticModel.GetDeclaredSymbol(p)) .ToImmutableArray(); if (parameterSymbols.Any(parameter => parameter == null)) { return; } foreach (var typeParameter in declaredSymbol.TypeParameters .Where(typeParameter => typeParameter.Variance == VarianceKind.None)) { var canBeIn = CheckTypeParameter(typeParameter, VarianceKind.In, declaredSymbol, returnType, parameterSymbols); var canBeOut = CheckTypeParameter(typeParameter, VarianceKind.Out, declaredSymbol, returnType, parameterSymbols); if (canBeIn ^ canBeOut) { ReportIssue(typeParameter, canBeIn ? VarianceKind.In : VarianceKind.Out, context); } } }
public override void VisitDelegateDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax node) { }
public override SyntaxNode VisitDelegateDeclaration(DelegateDeclarationSyntax node) { //Extend:Maybe add support depend on template, e.g. MS Ajax return node; }
internal Constructor( SourceMemberContainerTypeSymbol delegateType, TypeSymbol voidType, TypeSymbol objectType, TypeSymbol intPtrType, DelegateDeclarationSyntax syntax) : base(delegateType, voidType, syntax, MethodKind.Constructor, DeclarationModifiers.Public) { InitializeParameters(ImmutableArray.Create<ParameterSymbol>( new SynthesizedParameterSymbol(this, objectType, 0, RefKind.None, "object"), new SynthesizedParameterSymbol(this, intPtrType, 1, RefKind.None, "method"))); }
private static SyntaxNode HandleDelegateDeclaration(DelegateDeclarationSyntax node) { SyntaxToken triviaToken = node.DelegateKeyword; if (triviaToken.IsMissing) { return null; } SyntaxKind defaultVisibility = IsNestedType(node) ? SyntaxKind.PrivateKeyword : SyntaxKind.InternalKeyword; SyntaxTokenList modifiers = DeclarationModifiersHelper.AddModifier(node.Modifiers, ref triviaToken, defaultVisibility); return node .WithDelegateKeyword(triviaToken) .WithModifiers(modifiers) .WithoutFormatting(); }
internal InvokeMethod( SourceMemberContainerTypeSymbol delegateType, TypeSymbol returnType, DelegateDeclarationSyntax syntax, Binder binder, DiagnosticBag diagnostics) : base(delegateType, returnType, syntax, MethodKind.DelegateInvoke, DeclarationModifiers.Virtual | DeclarationModifiers.Public) { SyntaxToken arglistToken; var parameters = ParameterHelpers.MakeParameters(binder, this, syntax.ParameterList, true, out arglistToken, diagnostics); if (arglistToken.Kind() == SyntaxKind.ArgListKeyword) { // This is a parse-time error in the native compiler; it is a semantic analysis error in Roslyn. // error CS1669: __arglist is not valid in this context diagnostics.Add(ErrorCode.ERR_IllegalVarArgs, new SourceLocation(arglistToken)); } InitializeParameters(parameters); }
/// <summary> /// Given a delegate declaration, get the corresponding type symbol. /// </summary> /// <param name="declarationSyntax">The syntax node that declares a delegate.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>The type symbol that was declared.</returns> public override INamedTypeSymbol GetDeclaredSymbol(DelegateDeclarationSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken)) { CheckSyntaxNode(declarationSyntax); return GetDeclaredType(declarationSyntax); }
internal BeginInvokeMethod( InvokeMethod invoke, TypeSymbol iAsyncResultType, TypeSymbol objectType, TypeSymbol asyncCallbackType, DelegateDeclarationSyntax syntax) : base((SourceNamedTypeSymbol)invoke.ContainingType, iAsyncResultType, syntax, MethodKind.Ordinary, DeclarationModifiers.Virtual | DeclarationModifiers.Public) { var parameters = ArrayBuilder<ParameterSymbol>.GetInstance(); foreach (SourceParameterSymbol p in invoke.Parameters) { var synthesizedParam = new SourceClonedParameterSymbol(originalParam: p, newOwner: this, newOrdinal: p.Ordinal, suppressOptional: true); parameters.Add(synthesizedParam); } int paramCount = invoke.ParameterCount; parameters.Add(new SynthesizedParameterSymbol(this, asyncCallbackType, paramCount, RefKind.None, GetUniqueParameterName(parameters, "callback"))); parameters.Add(new SynthesizedParameterSymbol(this, objectType, paramCount + 1, RefKind.None, GetUniqueParameterName(parameters, "object"))); InitializeParameters(parameters.ToImmutableAndFree()); }
private static bool IsTaskReturningMethod(SemanticModel semanticModel, DelegateDeclarationSyntax delegateDeclarationSyntax, CancellationToken cancellationToken) { return IsTaskType(semanticModel, delegateDeclarationSyntax.ReturnType, cancellationToken); }
internal EndInvokeMethod( InvokeMethod invoke, TypeSymbol iAsyncResultType, DelegateDeclarationSyntax syntax) : base((SourceNamedTypeSymbol)invoke.ContainingType, invoke.ReturnType, syntax, MethodKind.Ordinary, DeclarationModifiers.Virtual | DeclarationModifiers.Public) { var parameters = ArrayBuilder<ParameterSymbol>.GetInstance(); int ordinal = 0; foreach (SourceParameterSymbol p in invoke.Parameters) { if (p.RefKind != RefKind.None) { var synthesizedParam = new SourceClonedParameterSymbol(originalParam: p, newOwner: this, newOrdinal: ordinal++, suppressOptional: true); parameters.Add(synthesizedParam); } } parameters.Add(new SynthesizedParameterSymbol(this, iAsyncResultType, ordinal++, RefKind.None, GetUniqueParameterName(parameters, "result"))); InitializeParameters(parameters.ToImmutableAndFree()); }
private void ClassifyUpdate(DelegateDeclarationSyntax oldNode, DelegateDeclarationSyntax newNode) { if (!SyntaxFactory.AreEquivalent(oldNode.Modifiers, newNode.Modifiers)) { ReportError(RudeEditKind.ModifiersUpdate); return; } if (!SyntaxFactory.AreEquivalent(oldNode.ReturnType, newNode.ReturnType)) { ReportError(RudeEditKind.TypeUpdate); return; } Debug.Assert(!SyntaxFactory.AreEquivalent(oldNode.Identifier, newNode.Identifier)); ReportError(RudeEditKind.Renamed); }
/// <summary> /// /// </summary> /// <param name="node"></param> public override sealed void VisitDelegateDeclaration(DelegateDeclarationSyntax node) { this.OnNodeVisited(node); if (!this.traverseRootOnly) base.VisitDelegateDeclaration(node); }