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