/// <summary>
/// Update the return type (if needed)
/// </summary>
private void FixReturnType(TargetFramework target)
{
var declaringType = method.DeclaringType;
if ((declaringType == null) || method.IsSignConverted || (!method.NeedsOverrideKeyword))
{
return;
}
var returnType = method.ReturnType;
if ((returnType is NetGenericParameter) && ((NetGenericParameter)returnType).Owner == method)
{
return;
}
var baseMethod = method.Overrides.First(x => !x.DeclaringType.IsInterface);
var expectedRetType = GenericParameters.Resolve(baseMethod.ReturnType, declaringType, target.TypeNameMap);
var retType = GenericParameters.Resolve(method.ReturnType, declaringType, target.TypeNameMap);
if (!retType.AreSame(expectedRetType))
{
if (baseMethod.IsAbstract)
{
method.ReturnType = expectedRetType;
}
else
{
method.RequireNewSlot();
}
}
}
/// <summary>
/// Add abstract method (that do not yet exist) for all interface methods.
/// </summary>
private void AddAbstractInterfaceMethods(NetTypeDefinition typeDef, TargetFramework target)
{
if ((typeDef.IsInterface) || (this is IInterfaceConstantsTypeBuilder))
{
return;
}
var typeMethods = typeDef.Methods.ToList();
foreach (var iterator in typeDef.Interfaces)
{
// Collect all interface methods
var iDef = iterator;
var iMethods = iDef.GetElementType().Methods.Select(x => Tuple.Create(iDef, x)).ToList();
iMethods.AddRange(iDef.GetElementType().GetBaseTypes(true).Where(x => x.GetElementType().IsInterface).SelectMany(x => x.GetElementType().Methods.Select(m => Tuple.Create(x, m))));
foreach (var pair in iMethods)
{
var iMethod = pair.Item2;
if (typeMethods.Any(x => x.IsExactDuplicate(iMethod)))
{
continue;
}
// Add abstract method
var method = new NetMethodDefinition(iMethod.Name, null, typeDef, target, iMethod.SignConvertMode, "TypeBuilder.AddAbstractInterfaceMethods");
method.AccessFlags = iMethod.AccessFlags;
method.Attributes = iMethod.Attributes;
method.IsAbstract = false;
method.IsVirtual = !typeDef.IsSealed;
method.GenericParameters.AddRange(iMethod.GenericParameters.Select(x => new NetGenericParameter(GetMethodGenericParameterName(typeDef, x.Name), x.Name, method)));
method.ReturnType = GenericParameters.Resolve(iMethod.ReturnType, typeDef, target.TypeNameMap);
method.Parameters.AddRange(iMethod.Parameters.Select(x => new NetParameterDefinition(x.Name, GenericParameters.Resolve(x.ParameterType, typeDef, target.TypeNameMap), x.IsParams)));
// Check if there are duplicates now that the generic parameters are resolved.
if (typeMethods.Any(x => x.IsExactDuplicate(method)))
{
continue;
}
// Should we ignore this one?
if (IgnoreInterfaceMethod(method, iMethod))
{
continue;
}
// Test if the method is a duplicate of an existing method, but with different return type
var differentAccessMask = !method.HasSameVisibility(iMethod);
if (differentAccessMask || typeMethods.Any(x => x.IsDuplicate(method)) ||
ImplementAsExplicitInterfaceMethod(method, iMethod) || typeDef.NestedTypes.Any(x => x.Name == method.Name))
{
// Method with different return type exists.
// Make it an explicit interface method
method.SetExplicitImplementation(iMethod, pair.Item1);
method.IsAbstract = false;
method.IsVirtual = false;
}
else
{
// Check for override
//method.IsOverride = isOverride;
if (method.IsOverride && method.Overrides.All(x => !x.IsVirtual))
{
// No need to override anything
continue;
}
}
// Create DexImport attribute
var typeCa = iMethod.DeclaringType.CustomAttributes.First(x => x.AttributeType == null);
var methodCa = iMethod.CustomAttributes.First(x => x.AttributeType == null);
var ca = new NetCustomAttribute(null, typeCa.ConstructorArguments[0], methodCa.ConstructorArguments[0], methodCa.ConstructorArguments[1]);
ca.CopyPropertiesFrom(methodCa);
method.CustomAttributes.Add(ca);
typeDef.Methods.Add(method);
typeMethods.Add(method);
// Avoid name conflicts
var nested = typeDef.NestedTypes.FirstOrDefault(x => x.Name == method.Name);
if (nested != null)
{
nested.Name = "Java" + nested.Name;
}
}
}
}
public string Visit(NetTypeDefinition type, bool addDummyGeneric)
{
string result;
if (type.DeclaringType != null)
{
// Nested
if (type == context)
{
result = type.Name;
}
else
{
var declType = type.DeclaringType.Accept(this, true);
result = declType + "." + type.Name;
}
}
else
{
result = type.FullName;
string mapped;
if (useShortTypeNames && shortTypeNameMap.TryGetValue(result, out mapped))
{
if ((mapped == "void") && !allowVoid)
{
mapped = "object";
}
result = mapped;
}
else
{
//if (/*(item.Namespace != "System") ||*/ (item.Name == "Exception") || (item.Name == "Type"))
{
result = "global::" + result;
}
}
}
if (addDummyGeneric && (type.GenericParameters.Count > 0))
{
var sb = new StringBuilder();
sb.Append('<');
var index = 0;
foreach (var gp in type.GenericParameters)
{
if (index > 0)
{
sb.Append(", ");
}
NetTypeReference resolvedGp;
var name = GenericParameters.TryResolve(gp, context, typeNameMap, out resolvedGp) ? resolvedGp.Accept(this, true) : "object";
sb.Append(name);
index++;
}
sb.Append('>');
result += sb;
// Add dummy type arguments
//var args = string.Join(", ", type.GenericParameters.Select(x => "object").ToArray());
//result = result + "<" + args + ">";
}
return(result);
}
/// <summary>
/// Remove all properties that override / implement a property that does not exist.
///
/// Will also fix property visibility.
/// </summary>
private void FixOverridenProperties(MethodRenamer methodRenamer, TargetFramework target)
{
if (!typeDef.Properties.Any())
{
return;
}
// handle overiding properties
var allBaseTypes = typeDef.GetBaseTypes(true);
var allBaseProperties = allBaseTypes.SelectMany(x => x.GetElementType().Properties).ToList();
var overridingProperties = typeDef.Properties.Where(x => IsAnyOverride(x) && !DoNotFixOverridenProperty(x)).ToList();
for (int i = 0; i < overridingProperties.Count; ++i)
{
var prop = overridingProperties[i];
NetPropertyDefinition matchingBaseProp = null;
if (prop.Getter != null)
{
// Note: this logic might need to be also applied for the "lone" setter logic below.
foreach (var baseProp in allBaseProperties.Where(p => p.Name == prop.Name))
{
var basePropType = GenericParameters.Resolve(baseProp.PropertyType, prop.DeclaringType, target.TypeNameMap);
if (!prop.PropertyType.AreSame(basePropType))
{
continue;
}
matchingBaseProp = baseProp;
break;
}
// Check for existing property in base class
if (matchingBaseProp == null)
{
// implement as normal method.
RemoveProperty(prop);
continue;
}
// Check for base property with setter
if (prop.Setter != null)
{
if (matchingBaseProp.Setter == null)
{
// Remove setter
prop.Setter.Property = null;
prop.Setter = null;
continue;
}
}
}
else
{
// this is a "lone" setter. for boolean setters, the name might have changed.
// try to match all base properties, update the name if neccessary.
foreach (var baseProp in allBaseProperties.Where(g => g.Getter != null && g.Setter != null))
{
if (FindSetter(baseProp.Getter, new[] { prop.Setter }, true) != null)
{
if (baseProp.Setter.IsVirtual)
{
if (matchingBaseProp == null || prop.Name == baseProp.Name)
{
matchingBaseProp = baseProp;
}
}
}
}
if (matchingBaseProp == null)
{
// remove the property alltogether
prop.Setter.Property = null;
typeDef.Properties.Remove(prop);
continue;
}
prop.Name = matchingBaseProp.Name;
}
// We must implement the property, since we inherited it.
// Fix up any clashes.
// clashes with explicit implementations should not occur.
if ((prop.Getter ?? prop.Setter).InterfaceType != null)
{
continue;
}
var propName = prop.Name;
if (propName == typeDef.Name)
{
if (!matchingBaseProp.DeclaringType.IsInterface)
{
Console.Error.WriteLine("Warning: Inherited property {0}::{1} clashes with type name. Skipping generation of property and methods.", typeDef.FullName, propName);
typeDef.Properties.Remove(prop);
typeDef.Methods.Remove(prop.Getter);
typeDef.Methods.Remove(prop.Setter);
continue;
}
// make this an explicit interface implementtion.
// TODO: We might also want to keep a renamed property in this case,
// too allow access to the property from the class.
// Also, the explicit implementation does not need a "JavaImport" attribute.
Console.Error.WriteLine("Warning: Inherited property {0}::{1} clashes with type name. Generating explicit implementation.", typeDef.FullName, propName);
if (prop.Getter != null)
{
if (matchingBaseProp.Getter != null)
{
prop.Getter.SetExplicitImplementation(matchingBaseProp.Getter, matchingBaseProp.DeclaringType);
}
else
{
prop.Getter = null;
}
}
if (prop.Setter != null)
{
if (matchingBaseProp.Setter != null)
{
prop.Setter.SetExplicitImplementation(matchingBaseProp.Setter, matchingBaseProp.DeclaringType);
}
else
{
prop.Setter = null;
}
}
continue;
}
if (typeDef.NestedTypes.Any(x => x.Name == propName))
{
Console.Error.WriteLine("Warning: Inherited property {0}::{1} clashes with nested type. Renaming nested type, but consider renaming the property instead.", typeDef.FullName, propName);
typeDef.NestedTypes.Where(x => x.Name == propName).ForEach(t => t.Name += "FixMe");
}
foreach (var clash in typeDef.Properties.Where(x => x != prop && x.Name == propName).ToList())
{
if (clash.Parameters.Count != prop.Parameters.Count)
{
continue;
}
if ((clash.Getter ?? clash.Setter).InterfaceType != null)
{
continue;
}
if (prop.PropertyType.AreSame(clash.PropertyType) &&
prop.MainMethod.CreateReason == "TypeBuilder.AddAbstractInterfaceMethods")
{
// it appears that the method does have an implementation!
typeDef.Properties.Remove(prop);
typeDef.Methods.Remove(prop.Getter);
typeDef.Methods.Remove(prop.Setter);
overridingProperties.RemoveAt(i);
i -= 1;
goto continue_outer;
}
if (overridingProperties.Contains(clash))
{
// This would have probably been removed later anyways.
//Console.Error.WriteLine("Warning: duplicate property names {0}::{1}. Not generating property for one of the clashes.", typeDef.FullName, propName);
RemoveProperty(clash);
overridingProperties.Remove(clash); // this must come after us.
continue;
}
// else remove other property
RemoveProperty(clash);
}
if (typeDef.Methods.Any(x => x != prop.Setter && x != prop.Getter && x.Name == propName))
{
Console.Error.WriteLine("Warning: Inherited property {0}::{1} clashes with methods. Prepending \"Invoke\" prefix to methods.", typeDef.FullName, propName);
typeDef.Methods.Where(x => x != prop.Setter && x != prop.Getter && x.Name == propName)
.ForEach(m => methodRenamer.Rename(m, "Invoke" + m.Name));
}
continue_outer :;
}
}