void CreateInterfaceImplementation(Class @interface)
{
var impl = new Class
{
Name = @interface.Name + "Impl",
Namespace = @interface.Namespace,
Type = ClassType.RefType,
IsFinal = true,
};
var @base = new BaseClassSpecifier {
Type = new TagType(@interface)
};
impl.Bases.Add(@base);
var methods = @interface.Declarations.Where(d => d is Method).Cast <Method>();
foreach (var method in methods)
{
var methodImpl = new Method(method)
{
IsPure = false,
IsImplicit = true,
IsOverride = true,
SynthKind = FunctionSynthKind.InterfaceInstance,
ExplicitInterfaceImpl = @interface
};
impl.Declarations.Add(methodImpl);
}
InterfaceImplementations.Add(impl);
}
private static T GetInternalImpl <T>(T @class) where T : Class, new()
{
var internalImpl = new T
{
Name = @class.Name + "Internal",
Access = AccessSpecifier.Private,
Namespace = @class.Namespace
};
if (@class.IsDependent)
{
internalImpl.IsDependent = true;
internalImpl.TemplateParameters.AddRange(@class.TemplateParameters);
foreach (var specialization in @class.Specializations)
{
var specializationImpl = AddInternalImplementation(specialization);
specializationImpl.Arguments.AddRange(specialization.Arguments);
specializationImpl.TemplatedDecl = specialization.TemplatedDecl;
internalImpl.Specializations.Add(specializationImpl);
}
}
var @base = new BaseClassSpecifier {
Type = new TagType(@class)
};
internalImpl.Bases.Add(@base);
return(internalImpl);
}
AST.BaseClassSpecifier VisitBaseClassSpecifier(BaseClassSpecifier @base)
{
var _base = new AST.BaseClassSpecifier
{
IsVirtual = @base.IsVirtual,
Access = VisitAccessSpecifier(@base.Access),
Type = typeConverter.Visit(@base.Type)
};
return(_base);
}
public void HandleBaseType(IKVM.Reflection.Type type, Class @class)
{
if (type.FullName == "System.Object" || type.FullName == "System.ValueType")
{
return;
}
var baseClass = Visit(type.GetTypeInfo()) as Class;
var specifier = new BaseClassSpecifier {
Type = new TagType(baseClass)
};
@class.Bases.Add(specifier);
}
private static Class GetInternalImpl(Declaration @class)
{
var internalImpl = new Class
{
Name = @class.Name + "Internal",
Access = AccessSpecifier.Private,
Namespace = @class.Namespace
};
var @base = new BaseClassSpecifier { Type = new TagType(@class) };
internalImpl.Bases.Add(@base);
return internalImpl;
}
public string GetBaseClassTemplateParameters(BaseClassSpecifier baseClassSpec)
{
if (!(baseClassSpec.Type is TemplateSpecializationType templateSpecType))
{
throw new NotSupportedException();
}
var args = templateSpecType.Arguments.Select(arg =>
{
arg.Type.Type.TryGetClass(out var @class);
return(@class);
});
return($"<{string.Join(", ", args.Select(c => c.Name))}>");
}
private static Class GetInternalImpl(Declaration @class)
{
var internalImpl = new Class
{
Name = @class.Name + "Internal",
Access = AccessSpecifier.Private,
Namespace = @class.Namespace
};
var @base = new BaseClassSpecifier {
Type = new TagType(@class)
};
internalImpl.Bases.Add(@base);
return(internalImpl);
}
void CreateInterfaceImplementation(Class @interface)
{
var impl = new Class
{
Name = @interface.Name + "Impl",
Namespace = @interface.Namespace,
Type = ClassType.RefType,
IsFinal = true,
};
var @base = new BaseClassSpecifier {
Type = new TagType(@interface)
};
impl.Bases.Add(@base);
var methods = new List <Method>(@interface.Declarations.OfType <Method>());
foreach (var baseInterface in @interface.Bases)
{
methods.AddRange(baseInterface.Class.Declarations.OfType <Method>());
}
foreach (var method in methods)
{
//NOTE: skip methods such as __getObject
if (method.IsImplicit)
{
continue;
}
var methodImpl = new Method(method)
{
IsPure = false,
IsImplicit = true,
IsOverride = true,
SynthKind = FunctionSynthKind.InterfaceInstance,
ExplicitInterfaceImpl = @interface,
Namespace = impl,
CompleteDeclaration = method
};
impl.Declarations.Add(methodImpl);
}
InterfaceImplementations.Add(impl);
}
public static BaseClassSpecifier __CreateInstance(BaseClassSpecifier.Internal native, bool skipVTables = false)
{
return new BaseClassSpecifier(native, skipVTables);
}
private static void* __CopyValue(BaseClassSpecifier.__Internal native)
{
var ret = Marshal.AllocHGlobal(16);
*(BaseClassSpecifier.__Internal*) ret = native;
return ret.ToPointer();
}
private BaseClassSpecifier(BaseClassSpecifier.Internal native)
: this(__CopyValue(native))
{
__ownsNativeInstance = true;
NativeToManagedMap[__Instance] = this;
}
public static BaseClassSpecifier __CreateInstance(BaseClassSpecifier.Internal native)
{
return new BaseClassSpecifier(native);
}
internal BaseClassSpecifier(BaseClassSpecifier.Internal native)
: this(__CopyValue(native))
{
}
private static global::System.IntPtr __CopyValue(BaseClassSpecifier.Internal native)
{
global::System.IntPtr ret = Marshal.AllocHGlobal(12);
*(BaseClassSpecifier.Internal*) ret = native;
return ret;
}
void CreateInterfaceImplementation(Class @interface)
{
var impl = new Class
{
Name = @interface.Name + "Impl",
Namespace = @interface.Namespace,
Type = ClassType.RefType,
IsFinal = true,
};
var @base = new BaseClassSpecifier {
Type = new TagType(@interface)
};
impl.Bases.Add(@base);
var methods = new List <Method>(@interface.Declarations.OfType <Method>());
foreach (var baseInterface in @interface.Bases)
{
foreach (var method in baseInterface.Class.Declarations.OfType <Method>())
{
// Skip methods that have been overriden previously in the chain.
if (methods.Any(m => MethodIsOverride(method, m)))
{
continue;
}
methods.Add(method);
}
}
foreach (var method in methods)
{
//NOTE: skip methods such as __getObject
if (method.IsImplicit)
{
continue;
}
if (!method.IsPure || method.IsFinal)
{
continue;
}
var methodImpl = CreateMethod(@interface, impl, method);
impl.Declarations.Add(methodImpl);
}
foreach (var property in @interface.Declarations.OfType <Property>())
{
if (property.IsImplicit)
{
continue;
}
if (!property.IsPure)
{
continue;
}
if (property.GetMethod != null)
{
var getMethodImpl = CreateMethod(@interface, impl, property.GetMethod);
impl.Declarations.Add(getMethodImpl);
}
if (property.SetMethod != null)
{
var setMethodImpl = CreateMethod(@interface, impl, property.SetMethod);
impl.Declarations.Add(setMethodImpl);
}
}
InterfaceImplementations.Add(impl);
}
private BaseClassSpecifier(BaseClassSpecifier.Internal native, bool skipVTables = false)
: this(__CopyValue(native), skipVTables)
{
__ownsNativeInstance = true;
NativeToManagedMap[__Instance] = this;
}
protected BaseClassSpecifier(BaseClassSpecifier.Internal* native, bool skipVTables = false)
{
if (native == null)
return;
__Instance = new global::System.IntPtr(native);
}
private BaseClassSpecifier(BaseClassSpecifier.Internal native)
: this(__CopyValue(native))
{
__ownsNativeInstance = true;
}
private static BaseClassSpecifier.Internal* __CopyValue(BaseClassSpecifier.Internal native)
{
var ret = (BaseClassSpecifier.Internal*) Marshal.AllocHGlobal(24);
*ret = native;
return ret;
}
internal BaseClassSpecifier(BaseClassSpecifier.Internal* native)
: this(new global::System.IntPtr(native))
{
}
protected BaseClassSpecifier(BaseClassSpecifier.Internal* native, bool isInternalImpl = false)
{
__Instance = new global::System.IntPtr(native);
}
internal BaseClassSpecifier(BaseClassSpecifier.Internal native)
: this(&native)
{
}
