private ParameterName CopyReturnParameter(MethodName parent)
{
if (_returnParameter == null)
{
return(null);
}
return(new DefaultReturnParameterName(parent, _returnParameter.ParameterType, _returnParameter.Modifiers));
}
internal MethodSpecificationName(MethodName elementName) : base(elementName.DeclaringType)
{
if (elementName == null)
{
throw new ArgumentNullException("elementName");
}
_elementName = elementName;
}
static MethodName RequireArg(MethodName declaring)
{
if (declaring == null)
{
throw new ArgumentNullException("declaring");
}
return(declaring);
}
public static TypeName FromType(Type type)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (type.IsByRef)
{
return(FromType(type.GetElementType()).MakeByReferenceType());
}
else if (type.IsArray)
{
return(FromType(type.GetElementType()).MakeArrayType(Enumerable.Repeat(ArrayDimension.Unsized, type.GetArrayRank())));
}
else if (type.IsPointer)
{
return(FromType(type.GetElementType()).MakePointerType());
}
else if (type.IsGenericParameter)
{
if (type.GetTypeInfo().DeclaringMethod == null)
{
return(GenericParameterName.New(FromType(type.DeclaringType), type.GenericParameterPosition, type.Name));
}
else
{
// TODO This is unbound, but getting the method is recursive
return(MethodName.GenericParameter(type.GenericParameterPosition));
}
}
else if (type.GetTypeInfo().IsGenericType)
{
return(ConvertGenericType(type));
}
else
{
TypeName declaring = null;
if (type.DeclaringType == null)
{
return(new DefaultTypeName(
AssemblyName.FromAssemblyName(type.GetTypeInfo().Assembly.GetName()),
type.Name,
type.Namespace ?? string.Empty));
}
else
{
declaring = FromType(type.DeclaringType);
return(new DefaultTypeName(type.Name, (DefaultTypeName)declaring));
}
}
}
private TypeName[] BindParameterTypes(MethodName method,
TypeName[] parameters)
{
for (int i = 0; i < parameters.Length; i++)
{
parameters[i] = parameters[i].CloneBind(this, method);
}
return(parameters);
}
internal SymbolName(string text)
{
_text = text;
_flags = (MethodName.TryParse(text, out _method) ? Flags.MethodName : 0)
| (FieldName.TryParse(text, out _field) ? Flags.FieldName : 0)
| (PropertyName.TryParse(text, out _property) ? Flags.PropertyName : 0)
| (EventName.TryParse(text, out _event) ? Flags.EventName : 0)
| (TypeName.TryParse(text, out _type) ? Flags.TypeName : 0)
| (ModuleName.TryParse(text, out _module) ? Flags.ModuleName : 0)
| (AssemblyName.TryParse(text, out _assembly) ? Flags.AssemblyName : 0)
| (NamespaceName.TryParse(text, out _namespace) ? Flags.NamespaceName : 0);
}
internal override TypeName CloneBind(TypeName declaring, MethodName method)
{
bool result;
TypeName et = CloneBindElement(declaring, method, out result);
if (result)
{
return(new ByReferenceTypeName(et));
}
else
{
return(this);
}
}
internal override TypeName CloneBind(TypeName declaring, MethodName method)
{
bool result;
TypeName et = CloneBindElement(declaring, method, out result);
if (result)
{
return(new ArrayTypeName(et, this.dimensions.ToArray()));
}
else
{
return(this);
}
}
private void PrintGenericParamsOrArgs(
StringBuilder buffer,
MethodName name,
bool usePositional)
{
IReadOnlyList <GenericParameterName> genericParameters = name.GenericParameters;
IEnumerable <TypeName> genericArguments = name.GenericArguments;
IEnumerable <TypeName> types = genericParameters;
if (types == null || !types.Any())
{
types = genericArguments;
}
if (genericParameters != null && genericParameters.Count > 0)
{
usePositional |= genericParameters[0].IsPositional;
}
// TODO We use Parameter to decide formatting of generics (probably need to
// introduce an alternative format)
var options = GetFormatHelper(this);
var defaultFormat = GetDefaultFormat(options, SymbolType.Parameter).Substring(0, 1);
if (types != null && types.Any())
{
if (usePositional)
{
buffer.Append("``" + types.Count());
return;
}
buffer.Append('<');
bool needComma = false;
foreach (var s in types)
{
if (needComma)
{
buffer.Append(", ");
}
buffer.Append(s.ToString(defaultFormat, this));
needComma = true;
}
buffer.Append('>');
}
}
internal sealed override TypeName CloneBind(TypeName declaring,
MethodName method)
{
var parms = IsMethodGenericParameter
? method.GenericParameters
: declaring.GenericParameters;
if (Position >= parms.Count)
{
throw DotNetFailure.CannotBindGenericParameterName();
}
else
{
return(parms[Position]);
}
}
protected internal virtual string FormatMethod(string format, MethodName name, IFormatProvider formatProvider)
{
StringBuilder sb = new StringBuilder();
var options = GetFormatHelper(formatProvider);
sb.Append(ComputeMethodDeclName(GetBasicFormat(format), name, options));
if (options.IncludeReturnTypes.Method && name.ReturnType != null)
{
string returnTypeFormat = string.Concat((options.DefaultFormatString.Parameter ?? string.Empty).Take(1));
sb.Append(":");
sb.Append(Format(returnTypeFormat, name.ReturnType, formatProvider));
}
return(sb.ToString());
}
// TODO Add GetMethod where there are generic parameters
public MethodName GetOperator(OperatorType operatorType)
{
if (operatorType == OperatorType.Unknown)
{
throw DotNetFailure.UnknownConversionOperatorCannotBeUsed("operatorType", operatorType);
}
if (operatorType == OperatorType.Explicit ||
operatorType == OperatorType.Implicit)
{
throw DotNetFailure.UnknownConversionOperatorCannotBeUsed("operatorType", operatorType);
}
if (MethodName.IsBinaryOperator(operatorType))
{
return(GetBinaryOperator(operatorType, this, this, this));
}
return(GetUnaryOperator(operatorType, this, this));
}
private void DoAppendParameters(StringBuilder buffer, MethodName name)
{
buffer.Append('(');
bool needComma = false;
foreach (var p in name.Parameters)
{
if (needComma)
{
buffer.Append(", ");
}
buffer.Append(p.ToString("U", null));
needComma = true;
}
buffer.Append(')');
}
public MethodName GetBinaryOperator(OperatorType operatorType,
TypeName leftOperandType,
TypeName rightOperandType,
TypeName resultType)
{
if (!MethodName.IsBinaryOperator(operatorType))
{
throw DotNetFailure.BinaryOperatorRequired("operatorType", operatorType);
}
string name = MethodName.GetOperator(operatorType);
return(new DefaultMethodName(
this,
name,
DefaultMethodName.SetParameters(new[] { leftOperandType ?? this, rightOperandType ?? this }),
DefaultMethodName.SetReturnType(resultType ?? this)
));
}
internal override TypeName CloneBind(TypeName declaring, MethodName method)
{
bool cloneNeeded;
var newElementType = CloneBindElement(declaring, method, out cloneNeeded);
var newArguments = this.typeArgs.ToArray();
int index = 0;
foreach (var element in this.GenericArguments)
{
var item = element.CloneBind(declaring, method);
cloneNeeded |= !object.ReferenceEquals(item, element);
newArguments[index] = item;
index++;
}
if (cloneNeeded)
{
return(new GenericInstanceTypeName(newElementType, newArguments));
}
return(this);
}
protected internal override string FormatMethod(string format,
MethodName name,
IFormatProvider formatProvider)
{
StringBuilder buffer = new StringBuilder();
// IComparer.CompareTo(Object, Object)
if (name.DeclaringType != null)
{
buffer.Append(name.DeclaringType.Name);
AppendNameSeparator(buffer, name.Name);
}
buffer.Append(name.Name);
PrintGenericParamsOrArgs(buffer, name, this.UseGenericParameterPositions);
if (name.HasParametersSpecified)
{
AppendMethodParameters(buffer, name.Parameters, "Cv", formatProvider);
}
return(buffer.ToString());
}
private static string ComputeMethodDeclName(BasicFormat f,
MethodName name,
MetadataNameFormat formatProvider)
{
switch (f)
{
case BasicFormat.Compact:
return(CompactFormat.FormatMethod(null, name, formatProvider));
case BasicFormat.Name:
return(name.Name);
case BasicFormat.NameOverloads:
return(NameOverloadsFormat.FormatMethod(null, name, formatProvider));
case BasicFormat.Full:
return(FullNameFormat.FormatMethod(null, name, formatProvider));
case BasicFormat.Roundtrip:
default:
return(RoundtrippableFormat.FormatMethod(null, name, formatProvider));
}
}
public TypeName ParseType()
{
_s.RequireMoveNext();
AssemblyName asm = ParseLeadAssemblyNameOpt();
if (_s.Type == TokenType.GenericPosition)
{
var gp = (GenericPositionToken)_s.Current;
MoveNext();
return(gp.IsMethod ? MethodName.GenericParameter(gp.Position)
: TypeName.GenericParameter(gp.Position));
}
if (_s.Type == TokenType.Identifier)
{
var type = ParseTypeWithSpecifiers();
// Could have the case where T<U,V>.N, a nested type in generics
while (type.IsGenericType && (_s.Type == TokenType.Plus || _s.Type == TokenType.Dot || _s.Type == TokenType.Slash))
{
_s.MoveNext();
var nested = ParseTypeWithSpecifiers();
type = nested.WithDeclaringType(type);
}
var trailAsm = ParseAssemblyNameOpt();
if (asm != null && trailAsm != null)
{
throw FormatError();
}
ParseEOF();
return(type.WithAssembly(asm ?? trailAsm));
}
throw FormatError();
}
protected override GenericParameterName UpdateOverride(MethodName declaringMethod)
{
throw new NotImplementedException();
}
internal virtual TypeName CloneBind(TypeName declaring, MethodName method)
{
return(this);
}
internal GenericInstanceMethodName(MethodName elementName,
TypeName[] arguments)
: base(elementName)
{
_arguments = arguments;
}
internal override TypeName CloneBind(TypeName declaring, MethodName method)
{
return(this);
}
internal static GenericParameterName New(MethodName declaring, int position, string name)
{
return(new BoundGenericParameterName(declaring, position, name));
}
protected abstract GenericParameterName UpdateOverride(MethodName declaringMethod);
public MethodName ParseMethod()
{
_s.RequireMoveNext();
string name = null;
int sz = 0; // of generics
TypeName declaringType = ParseDeclaringTypeOpt(out name);
ParameterData[] pms = null;
TypeName returnType = null;
AssemblyName asm = null;
if (_s.Type == TokenType.DoubleColon)
{
throw new NotImplementedException();
}
name = MethodName.StripMangle(name, out sz);
bool hasGenericParams = _s.Type == TokenType.LessThan;
var generics = ParseTypeParametersOpt();
if (hasGenericParams)
{
MoveNext();
}
if (_s.Type == TokenType.LeftParen)
{
pms = ParseParameters(TokenType.RightParen).ToArray();
_s.MoveToContent();
}
returnType = ParseReturnTypeOpt();
asm = ParseAssemblyNameOpt();
ParseEOF();
if (declaringType != null)
{
declaringType = declaringType.WithAssembly(asm);
}
if (!hasGenericParams && sz > 0)
{
// Method``2(A,B) -- mangled but no type parameter syntax
return(new DefaultMethodName(
declaringType,
name,
DefaultMethodName.SetGenericMangle(sz),
DefaultMethodName.SetParameters(pms),
DefaultMethodName.SetReturnType(returnType)
));
}
else if (generics.MustBeParameters || (generics.CouldBeParameters && _preferGenericParamsInMethods))
{
return(new DefaultMethodName(
declaringType,
name,
DefaultMethodName.SetGenerics(generics.ConvertToGenerics(true).ToArray()),
DefaultMethodName.SetParameters(pms),
DefaultMethodName.SetReturnType(returnType)
));
// TODO Could have discrepancy between generics declared with position and
// named in type parameter list (sz != generics.Raw.Count)
}
else
{
var elementName = new DefaultMethodName(
declaringType,
name,
DefaultMethodName.SetGenericMangle(generics.Raw.Count),
DefaultMethodName.SetParameters(pms),
DefaultMethodName.SetReturnType(returnType)
);
return(new GenericInstanceMethodName(elementName, generics.Raw.ToArray()));
}
}
public static bool TryParse(string text, out MethodName result)
{
return(_TryParse(text, out result) == null);
}
