/// <summary>
/// Creates a method signature from a method's name,
/// the number of generic parameters the method
/// takes, its return type and its parameter types.
/// </summary>
/// <param name="name">
/// The name of the method signature.
/// </param>
/// <param name="genericParameterCount">
/// The number of generic parameters in the method
/// signature.
/// </param>
/// <param name="returnType">
/// The return type of the method signature.
/// </param>
/// <param name="parameterTypes">
/// The types of the method signature's parameters.
/// </param>
/// <returns>A method signature.</returns>
public static ClrMethodSignature Create(
UnqualifiedName name,
int genericParameterCount,
IType returnType,
IReadOnlyList <IType> parameterTypes)
{
var result = new ClrMethodSignature();
result.Name = name;
result.GenericParameterCount = genericParameterCount;
// Replace generic parameters with standins.
var visitor = new GenericParameterToStandinVisitor();
result.ReturnType = visitor.Visit(returnType);
result.ParameterTypes = visitor
.VisitAll(parameterTypes)
.ToImmutableArray();
return(result);
}
/// <summary>
/// Encodes an unqualified name as a simple name.
/// </summary>
/// <param name="name">
/// An unqualified name to encode. Simple names are encoded
/// as such. Other names are encoded as simple names by taking
/// their string representation.
/// </param>
/// <returns>An encoded node.</returns>
public LNode Encode(UnqualifiedName name)
{
if (name is SimpleName)
{
var simple = (SimpleName)name;
var simpleNameNode = Factory.Id(simple.Name);
if (simple.TypeParameterCount == 0)
{
return(simpleNameNode);
}
else
{
return(Factory.Call(
simpleNameNode,
Factory.Literal(simple.TypeParameterCount)));
}
}
else
{
return(Factory.Id(name.ToString()));
}
}
/// <summary>
/// Creates a type from a name and a parent type.
/// </summary>
/// <param name="name">The type's unqualified name.</param>
/// <param name="parentType">
/// The type's parent type, i.e., the type that defines it.
/// </param>
public DescribedType(UnqualifiedName name, IType parentType)
: base(name.Qualify(parentType.FullName))
{
this.Parent = new TypeParent(parentType);
Initialize();
}
public override int GetHashCode() => UnqualifiedName.GetHashCode();
/// <summary>
/// Finds all nested types defined by a particular type that have
/// a specific unqualified name.
/// </summary>
/// <param name="parentType">The type that defines the nested types.</param>
/// <param name="name">The unqualified name to look for.</param>
/// <returns>
/// A list of types that are defined by <paramref name="parentType"/>
/// and have name <paramref name="name"/>.
/// </returns>
public IReadOnlyList <IType> ResolveNestedTypes(IType parentType, UnqualifiedName name)
{
return(resolver.ResolveNestedTypes(parentType, name));
}
/// <summary>
/// Finds all generic parameters defined by a particular member that have
/// a specific unqualified name.
/// </summary>
/// <param name="parentMember">
/// The generic member that defines the generic parameters.
/// </param>
/// <param name="name">The unqualified name to look for.</param>
/// <returns>
/// A list of generic parameters that are defined by <paramref name="parentMember"/>
/// and have name <paramref name="name"/>.
/// </returns>
public IReadOnlyList <IType> ResolveGenericParameters(
IGenericMember parentMember,
UnqualifiedName name)
{
return(resolver.ResolveGenericParameters(parentMember, name));
}
private static IReadOnlyList <IType> ResolvePrecise(
TypeResolverNamespace ns,
UnqualifiedName name)
{
return(ns.ResolveTypes(name));
}
/// <summary>
/// Finds all nested types defined by a particular type that have
/// a specific unqualified name.
/// </summary>
/// <param name="parentType">The type that defines the nested types.</param>
/// <param name="name">The unqualified name to look for.</param>
/// <returns>
/// A list of types that are defined by <paramref name="parentType"/>
/// and have name <paramref name="name"/>.
/// </returns>
public IReadOnlyList <IType> ResolveNestedTypes(IType parentType, UnqualifiedName name)
{
return(ResolveNestedTypesImpl <UnqualifiedName>(parentType, name, ResolvePrecise));
}
Name ParseUnqualifiedName(ref int p)
{
var t = Symbol.Text;
var ch = t[p];
var op = OperatorName.TryGet(t, ref p);
if (op != null)
{
return(op);
}
if (ch == 'C' || ch == 'D')
{
var k = t.Substring(p, 2);
var ident = k;
switch (k)
{
case "C1":
ident = "ctor";
break;
case "C2":
ident = "ctor_base";
break;
case "C3":
ident = "ctor_alloc";
break;
case "D0":
ident = "dtor_free";
break;
case "D1":
ident = "dtor";
break;
case "D2":
ident = "dtor_base";
break;
}
var n = new CtorName {
Kind = k, Ident = ident
};
p += 2;
return(n);
}
Name prefix = null;
if (ch == 'S' && p + 1 < t.Length && t[p + 1] == 't')
{
p += 2;
prefix = Name.Std;
}
var e = p;
while (char.IsDigit(t[e]) && e + 1 < t.Length)
{
e++;
}
if (e == p)
{
SyntaxError("Bad Source Name", p);
return(null);
}
var length = int.Parse(t.Substring(p, e - p));
var text = t.Substring(e, length);
p = e + length;
var un = new UnqualifiedName {
Text = text
};
if (prefix == null)
{
return(un);
}
return(new NestedName {
Names = { prefix, un }
});
}
/// <inheritdoc/>
public override bool Equals(UnqualifiedName Other)
{
return(Other is PreMangledName && ((PreMangledName)Other).MangledName.Equals(MangledName));
}
/// <summary>
/// Creates a pre-mangled name from the given names.
/// </summary>
/// <param name="MangledName">The mangled name.</param>
/// <param name="UnmangledName">The unmangled name.</param>
public PreMangledName(string MangledName, UnqualifiedName UnmangledName)
{
this.MangledName = MangledName;
this.UnmangledName = UnmangledName;
}
