bool ISupportsInterning.EqualsForInterning(ISupportsInterning other)
{
DefaultUnresolvedParameter p = other as DefaultUnresolvedParameter;
return(p != null && type == p.type && attributes == p.attributes && name == p.name &&
defaultValue == p.defaultValue && region == p.region && flags == p.flags);
}
bool ISupportsInterning.EqualsForInterning(ISupportsInterning other)
{
// compare everything except for the IsFrozen flag
DefaultUnresolvedParameter p = other as DefaultUnresolvedParameter;
return(p != null && type == p.type && name == p.name &&
defaultValue == p.defaultValue && region == p.region && (flags & ~1) == (p.flags & ~1) && ListEquals(attributes, p.attributes));
}
static void AddPlaceholders(Step action, IUnresolvedMethod method)
{
var parameters = new List<IUnresolvedParameter> ();
int index = 0;
foreach (var placeholder in action.Placeholders) {
var typeRef = new DefaultUnresolvedTypeDefinition (placeholder.Name);
var p = new DefaultUnresolvedParameter (typeRef, "p" + index);
method.Parameters.Add (p);
index++;
}
}
static IUnresolvedMethod FunctionToIMethod (ProjectInformation pi, IUnresolvedTypeDefinition type, Function function, string[] contentLines)
{
var method = new DefaultUnresolvedMethod (type, function.Name);
method.Region = new DomRegion ((int)function.Line, 1, FindFunctionEnd (contentLines, (int)function.Line-1)+2, 1);
Match match;
bool abort = false;
var parameters = new List<IUnresolvedParameter> ();
foreach (string parameter in function.Parameters) {
match = paramExpression.Match (parameter);
if (null == match) {
abort = true;
break;
}
var typeRef = new DefaultUnresolvedTypeDefinition (string.Format ("{0}{1}{2}", match.Groups["type"].Value, match.Groups["subtype"].Value, match.Groups["array"].Value));
var p = new DefaultUnresolvedParameter (typeRef, match.Groups["name"].Value);
parameters.Add (p);
}
if (!abort)
parameters.ForEach (p => method.Parameters.Add (p));
return method;
}
void AddAttributes(ParameterInfo parameter, DefaultUnresolvedParameter targetParameter)
{
if (!targetParameter.IsOut) {
if (parameter.IsIn)
targetParameter.Attributes.Add(inAttribute);
if (parameter.IsOut)
targetParameter.Attributes.Add(outAttribute);
}
AddCustomAttributes(parameter.CustomAttributes, targetParameter.Attributes);
FieldMarshal marshalInfo;
if (parameter.__TryGetFieldMarshal (out marshalInfo)) {
targetParameter.Attributes.Add(ConvertMarshalInfo(marshalInfo));
}
}
public IUnresolvedParameter ReadParameter(ParameterInfo parameter)
{
if (parameter == null)
throw new ArgumentNullException("parameter");
var type = ReadTypeReference(parameter.ParameterType, typeAttributes: parameter.CustomAttributes);
var p = new DefaultUnresolvedParameter(type, interningProvider.Intern(parameter.Name ?? "index"));
if (parameter.ParameterType.IsByRef) {
if (!parameter.IsIn && parameter.IsOut)
p.IsOut = true;
else
p.IsRef = true;
}
AddAttributes(parameter, p);
if (parameter.IsOptional) {
p.DefaultValue = CreateSimpleConstantValue(type, parameter.RawDefaultValue);
}
if (parameter.ParameterType.IsArray) {
foreach (var att in parameter.CustomAttributes) {
if (att.AttributeType.FullName == typeof(ParamArrayAttribute).FullName) {
p.IsParams = true;
break;
}
}
}
return interningProvider.Intern(p);
}
public IUnresolvedParameter ReadParameter(ParameterInfo parameter)
{
if (parameter == null)
throw new ArgumentNullException("parameter");
var customAttributes = parameter.CustomAttributes;
var parameterType = parameter.ParameterType;
var type = ReadTypeReference(parameterType, typeAttributes: customAttributes);
var p = new DefaultUnresolvedParameter(type, interningProvider.Intern(parameter.Name ?? "index"));
if (parameterType.IsByRef) {
if (!parameter.IsIn && parameter.IsOut)
p.IsOut = true;
else
p.IsRef = true;
}
AddAttributes(parameter, p, customAttributes);
if (parameter.IsOptional) {
p.DefaultValue = CreateSimpleConstantValue(type, parameter.RawDefaultValue);
}
if (parameterType.IsArray) {
foreach (var att in customAttributes) {
var dt = att.Constructor.DeclaringType;
if (dt.__Name == "ParamArrayAttribute" && dt.Namespace == "System") {
p.IsParams = true;
break;
}
}
}
return interningProvider.Intern(p);
}
//TODO: handle generics
public static IUnresolvedMethod CodeDomToMDDomMethod (CodeMemberMethod method)
{
var meth = new DefaultUnresolvedMethod (null, method.Name);
meth.ReturnType = new DefaultUnresolvedTypeDefinition (method.ReturnType.BaseType);
CodeDomModifiersToMDDom (meth, method.Attributes);
foreach (CodeParameterDeclarationExpression dec in method.Parameters) {
var paramType = new DefaultUnresolvedTypeDefinition (dec.Type.BaseType);
var par = new DefaultUnresolvedParameter (paramType, dec.Name);
if (dec.Direction == FieldDirection.Ref)
par.IsRef = true;
else if (dec.Direction == FieldDirection.Out)
par.IsOut = true;
meth.Parameters.Add (par);
}
return meth;
}
static IUnresolvedParameter TransformParameterInfo(ArgumentAnnotation argAnnotation)
{
var name = argAnnotation.Name;
bool has_variable_params = false;
if(name.EndsWith(".")){ //parameter names that end with trailing "..." indicate that the parameters can take arbitrary number of arguments
has_variable_params = true;
name = name.Substring(0, name.Length - 3);
}
var param = new DefaultUnresolvedParameter(PrimitiveTypeReference.Get(argAnnotation.ParamType), name);
param.IsParams = has_variable_params;
return param;
}
