/// <summary>
/// Creates a method of the appropriate subtype.
/// </summary>
/// <param name="cx"></param>
/// <param name="methodDecl"></param>
/// <returns></returns>
public static Method Create(Context cx, IMethodSymbol methodDecl)
{
if (methodDecl == null)
{
return(null);
}
switch (methodDecl.MethodKind)
{
case MethodKind.StaticConstructor:
case MethodKind.Constructor:
return(Constructor.Create(cx, methodDecl));
case MethodKind.ReducedExtension:
case MethodKind.Ordinary:
case MethodKind.DelegateInvoke:
case MethodKind.ExplicitInterfaceImplementation:
return(OrdinaryMethod.Create(cx, methodDecl));
case MethodKind.Destructor:
return(Destructor.Create(cx, methodDecl));
case MethodKind.PropertyGet:
case MethodKind.PropertySet:
return(Accessor.Create(cx, methodDecl));
case MethodKind.EventAdd:
case MethodKind.EventRemove:
return(EventAccessor.Create(cx, methodDecl));
case MethodKind.UserDefinedOperator:
case MethodKind.BuiltinOperator:
return(UserOperator.Create(cx, methodDecl));
case MethodKind.Conversion:
return(Conversion.Create(cx, methodDecl));
case MethodKind.AnonymousFunction:
throw new InternalError(methodDecl, "Attempt to create a lambda");
case MethodKind.LocalFunction:
return(LocalFunction.Create(cx, methodDecl));
default:
throw new InternalError(methodDecl, "Unhandled method '{0}' of kind '{1}'", methodDecl, methodDecl.MethodKind);
}
}
public override void Populate()
{
var type = Type.Create(Context, symbol.Type);
Context.Emit(Tuples.indexers(this, symbol.GetName(useMetadataName: true), ContainingType, type.TypeRef, OriginalDefinition));
foreach (var l in Locations)
{
Context.Emit(Tuples.indexer_location(this, l));
}
var getter = symbol.GetMethod;
var setter = symbol.SetMethod;
if (getter == null && setter == null)
{
Context.ModelError(symbol, "No indexer accessor defined");
}
if (getter != null)
{
Getter = Accessor.Create(Context, getter);
}
if (setter != null)
{
Setter = Accessor.Create(Context, setter);
}
for (var i = 0; i < symbol.Parameters.Length; ++i)
{
var original = Parameter.Create(Context, symbol.OriginalDefinition.Parameters[i], OriginalDefinition);
Parameter.Create(Context, symbol.Parameters[i], this, original);
}
if (getter != null)
{
Getter = Accessor.Create(Context, getter);
Context.Emit(Tuples.accessors(Getter, 1, getter.Name, this, Getter.OriginalDefinition));
Context.Emit(Tuples.accessor_location(Getter, Getter.Location));
Getter.Overrides();
Getter.ExtractModifiers();
}
if (setter != null)
{
Setter = Accessor.Create(Context, setter);
Context.Emit(Tuples.accessors(Setter, 2, setter.Name, this, Setter.OriginalDefinition));
Context.Emit(Tuples.accessor_location(Setter, Setter.Location));
Setter.Overrides();
Setter.ExtractModifiers();
}
if (IsSourceDeclaration)
{
var expressionBody = ExpressionBody;
if (expressionBody != null)
{
// The expression may need to reference parameters in the getter.
// So we need to arrange that the expression is populated after the getter.
Context.PopulateLater(() => Expression.CreateFromNode(new ExpressionNodeInfo(Context, expressionBody, this, 0)
{
Type = Type.Create(Context, symbol.Type)
}));
}
}
ExtractModifiers();
BindComments();
var declSyntaxReferences = IsSourceDeclaration
? symbol.DeclaringSyntaxReferences.
Select(d => d.GetSyntax()).OfType <IndexerDeclarationSyntax>().ToArray()
: Enumerable.Empty <IndexerDeclarationSyntax>();
foreach (var explicitInterface in symbol.ExplicitInterfaceImplementations.Select(impl => Type.Create(Context, impl.ContainingType)))
{
Context.Emit(Tuples.explicitly_implements(this, explicitInterface.TypeRef));
foreach (var syntax in declSyntaxReferences)
{
TypeMention.Create(Context, syntax.ExplicitInterfaceSpecifier.Name, this, explicitInterface);
}
}
foreach (var syntax in declSyntaxReferences)
{
TypeMention.Create(Context, syntax.Type, this, type);
}
}
/// <summary>
/// Creates a method of the appropriate subtype.
/// </summary>
/// <param name="cx"></param>
/// <param name="methodDecl"></param>
/// <returns></returns>
public static Method Create(Context cx, IMethodSymbol methodDecl)
{
if (methodDecl == null)
{
return(null);
}
var methodKind = methodDecl.MethodKind;
if (methodKind == MethodKind.ExplicitInterfaceImplementation)
{
// Retrieve the original method kind
methodKind = methodDecl.ExplicitInterfaceImplementations.Select(m => m.MethodKind).FirstOrDefault();
}
switch (methodKind)
{
case MethodKind.StaticConstructor:
case MethodKind.Constructor:
return(Constructor.Create(cx, methodDecl));
case MethodKind.ReducedExtension:
case MethodKind.Ordinary:
case MethodKind.DelegateInvoke:
return(OrdinaryMethod.Create(cx, methodDecl));
case MethodKind.Destructor:
return(Destructor.Create(cx, methodDecl));
case MethodKind.PropertyGet:
case MethodKind.PropertySet:
return(methodDecl.AssociatedSymbol is null?OrdinaryMethod.Create(cx, methodDecl) : (Method)Accessor.Create(cx, methodDecl));
case MethodKind.EventAdd:
case MethodKind.EventRemove:
return(EventAccessor.Create(cx, methodDecl));
case MethodKind.UserDefinedOperator:
case MethodKind.BuiltinOperator:
return(UserOperator.Create(cx, methodDecl));
case MethodKind.Conversion:
return(Conversion.Create(cx, methodDecl));
case MethodKind.AnonymousFunction:
throw new InternalError(methodDecl, "Attempt to create a lambda");
case MethodKind.LocalFunction:
return(LocalFunction.Create(cx, methodDecl));
default:
throw new InternalError(methodDecl, $"Unhandled method '{methodDecl}' of kind '{methodDecl.MethodKind}'");
}
}
public override void Populate()
{
ExtractAttributes();
ExtractModifiers();
BindComments();
var type = Type.Create(Context, symbol.Type);
Context.Emit(Tuples.properties(this, symbol.GetName(), ContainingType, type.TypeRef, Create(Context, symbol.OriginalDefinition)));
var getter = symbol.GetMethod;
if (getter != null)
{
Getter = Accessor.Create(Context, getter);
}
var setter = symbol.SetMethod;
if (setter != null)
{
Setter = Accessor.Create(Context, setter);
}
var declSyntaxReferences = IsSourceDeclaration ?
symbol.DeclaringSyntaxReferences.
Select(d => d.GetSyntax()).OfType <PropertyDeclarationSyntax>().ToArray()
: Enumerable.Empty <PropertyDeclarationSyntax>();
foreach (var explicitInterface in symbol.ExplicitInterfaceImplementations.Select(impl => Type.Create(Context, impl.ContainingType)))
{
Context.Emit(Tuples.explicitly_implements(this, explicitInterface.TypeRef));
foreach (var syntax in declSyntaxReferences)
{
TypeMention.Create(Context, syntax.ExplicitInterfaceSpecifier.Name, this, explicitInterface);
}
}
foreach (var l in Locations)
{
Context.Emit(Tuples.property_location(this, l));
}
if (IsSourceDeclaration && symbol.FromSource())
{
var expressionBody = ExpressionBody;
if (expressionBody != null)
{
Context.PopulateLater(() => Expression.Create(Context, expressionBody, this, 0));
}
foreach (var initializer in declSyntaxReferences.
Select(n => n.Initializer).
Where(i => i != null).
Select(i => i.Value))
{
Context.PopulateLater(() => Expression.Create(Context, initializer, this, 1));
}
foreach (var syntax in declSyntaxReferences)
{
TypeMention.Create(Context, syntax.Type, this, type);
}
}
}
public static Method?Create(Context cx, IMethodSymbol?methodDecl)
{
if (methodDecl is null)
{
return(null);
}
var methodKind = methodDecl.MethodKind;
if (methodKind == MethodKind.ExplicitInterfaceImplementation)
{
// Retrieve the original method kind
methodKind = methodDecl.ExplicitInterfaceImplementations.Select(m => m.MethodKind).FirstOrDefault();
}
switch (methodKind)
{
case MethodKind.StaticConstructor:
case MethodKind.Constructor:
return(Constructor.Create(cx, methodDecl));
case MethodKind.ReducedExtension:
if (SymbolEqualityComparer.Default.Equals(methodDecl, methodDecl.ConstructedFrom))
{
return(OrdinaryMethod.Create(cx, methodDecl.ReducedFrom !));
}
return(OrdinaryMethod.Create(cx, methodDecl.ReducedFrom !.Construct(methodDecl.TypeArguments, methodDecl.TypeArgumentNullableAnnotations)));
case MethodKind.Ordinary:
case MethodKind.DelegateInvoke:
return(OrdinaryMethod.Create(cx, methodDecl));
case MethodKind.Destructor:
return(Destructor.Create(cx, methodDecl));
case MethodKind.PropertyGet:
case MethodKind.PropertySet:
return(Accessor.GetPropertySymbol(methodDecl) is IPropertySymbol prop?Accessor.Create(cx, methodDecl, prop) : OrdinaryMethod.Create(cx, methodDecl));
case MethodKind.EventAdd:
case MethodKind.EventRemove:
return(EventAccessor.GetEventSymbol(methodDecl) is IEventSymbol @event?EventAccessor.Create(cx, methodDecl, @event) : OrdinaryMethod.Create(cx, methodDecl));
case MethodKind.UserDefinedOperator:
case MethodKind.BuiltinOperator:
return(UserOperator.Create(cx, methodDecl));
case MethodKind.Conversion:
return(Conversion.Create(cx, methodDecl));
case MethodKind.AnonymousFunction:
throw new InternalError(methodDecl, "Attempt to create a lambda");
case MethodKind.LocalFunction:
return(LocalFunction.Create(cx, methodDecl));
default:
throw new InternalError(methodDecl, $"Unhandled method '{methodDecl}' of kind '{methodDecl.MethodKind}'");
}
}
