public static MethodName FromMethodInfo(System.Reflection.MethodInfo method)
{
if (method == null)
{
throw new ArgumentNullException(nameof(method));
}
if (method.IsGenericMethod && !method.IsGenericMethodDefinition)
{
return(new GenericInstanceMethodName(
FromMethodInfo(method.GetGenericMethodDefinition()),
method.GetGenericArguments().Select(TypeName.FromType).ToArray()
));
}
var generics = DefaultMethodName.SetGenericMangle(0);
if (method.IsGenericMethodDefinition)
{
generics = DefaultMethodName.SetGenericArguments(method.GetGenericArguments());
}
var result = new DefaultMethodName(
TypeName.FromType(method.DeclaringType),
method.Name,
generics,
DefaultMethodName.SetParameters(method.GetParameters()),
DefaultMethodName.SetReturnType(TypeName.FromType(method.ReturnType))
);
return(result);
}
private static IEnumerable <TypeName> BindParameterTypes(DefaultMethodName method, IEnumerable <TypeName> parameters)
{
foreach (var p in parameters)
{
yield return(p.CloneBind(method.DeclaringType, method));
}
}
public MethodName GetMethod(string name, TypeName returnType, IEnumerable <string> typeParameters, IEnumerable <TypeName> parameters)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (name.Length == 0)
{
throw Failure.EmptyString(nameof(name));
}
if (returnType == null)
{
throw new ArgumentNullException("returnType");
}
typeParameters = typeParameters ?? Array.Empty <string>();
parameters = parameters ?? Array.Empty <TypeName>();
if (typeParameters.Any(t => t == null))
{
throw Failure.CollectionContainsNullElement("typeParameters");
}
if (parameters.Any(t => t == null))
{
throw Failure.CollectionContainsNullElement("parameters");
}
return(new DefaultMethodName(
this,
name,
DefaultMethodName.SetGenericParameters(typeParameters),
DefaultMethodName.SetParameters(parameters),
DefaultMethodName.SetReturnType(returnType)
));
}
public MethodName GetMethod(string name, params TypeName[] parameters)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (name.Length == 0)
{
throw Failure.EmptyString(nameof(name));
}
parameters = parameters ?? Array.Empty <TypeName>();
if (parameters.Any(t => t == null))
{
throw Failure.CollectionContainsNullElement("parameters");
}
int mangle;
var method = TypeName.StripMangle(name, out mangle);
return(new DefaultMethodName(
this,
method,
DefaultMethodName.SetGenericMangle(mangle),
DefaultMethodName.SetParameters(parameters)
));
}
public override MethodName WithName(string name)
{
var result = new DefaultMethodName(DeclaringType, name);
result._parameters = _parameters;
result._genericParameters = _genericParameters;
result._returnParameter = CopyReturnParameter(this);
return(result);
}
protected override MemberName WithDeclaringTypeOverride(TypeName declaringType)
{
var result = new DefaultMethodName(declaringType, _name);
result._parameters = _parameters;
result._genericParameters = _genericParameters;
result._returnParameter = CopyReturnParameter(this);
return(result);
}
private MethodName GetGetMethod()
{
string name = "get_" + Name;
return(new DefaultMethodName(
DeclaringType,
name,
DefaultMethodName.SetParameters(IndexParameters.Select(t => t.ParameterType)),
DefaultMethodName.SetReturnType(PropertyType)
));
}
public override MethodName WithReturnParameter(TypeName returnType, IEnumerable <TypeName> requiredModifiers, IEnumerable <TypeName> optionalModifiers)
{
var result = new DefaultMethodName(DeclaringType, _name);
result._parameters = _parameters;
result._genericParameters = _genericParameters;
var modifiers = new ModifierCollection(requiredModifiers, optionalModifiers);
result._returnParameter = new DefaultReturnParameterName(this, returnType, modifiers);
return(result);
}
internal override MethodName WithGenericParameters(GenericParameterName[] parameters)
{
var result = new DefaultMethodName(DeclaringType, _name);
result.FinalizeGenerics(parameters);
result.FinalizeParameters(ParameterData.AsData(_parameters).ToArray());
if (ReturnType != null)
{
result.FinalizeReturnType(ReturnType.CloneBind(DeclaringType, result));
}
return(result);
}
public static MethodName FromConstructorInfo(System.Reflection.ConstructorInfo constructor)
{
if (constructor == null)
{
throw new ArgumentNullException("constructor");
}
return(new DefaultMethodName(
TypeName.FromType(constructor.DeclaringType),
constructor.Name,
DefaultMethodName.SetGenericMangle(0),
DefaultMethodName.SetParameters(
ParameterData.ConvertAll(constructor.GetParameters())
)
));
}
private MethodName GetSetMethod()
{
string name = "set_" + Name;
var parameters = new ParameterData[IndexParameters.Count + 1];
parameters[parameters.Length - 1] = new ParameterData("value", PropertyType);
var indexes = ParameterData.AllFromTypes(IndexParameters.Select(t => t.ParameterType));
indexes.CopyTo(parameters, 0);
return(new DefaultMethodName(
DeclaringType,
name,
DefaultMethodName.SetParameters(parameters),
DefaultMethodName.SetReturnType(TypeName.Void)
));
}
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)
));
}
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()));
}
}
