static List <string> HomonymPartsFor(FunctionDeclaration func, TypeMapper mapper)
{
var parts = func.ParameterLists.Last().Select(arg => arg.NameIsRequired ? arg.PublicName : "_").ToList();
if (func.ReturnTypeSpec == null || func.ReturnTypeSpec.IsEmptyTuple)
{
parts.Add("void");
}
else
{
var use = new CSUsingPackages();
if (func.ReturnTypeSpec is ProtocolListTypeSpec pl)
{
var sb = new StringBuilder();
foreach (var nt in pl.Protocols.Keys)
{
sb.Append(MangledReturnType(func, mapper, use, nt));
}
parts.Add(sb.ToString());
}
else
{
parts.Add(MangledReturnType(func, mapper, use, func.ReturnTypeSpec));
}
}
return(parts);
}
CSInterface BuildCSIface(ClassDeclaration cl, CSUsingPackages use)
{
var csName = NewClassCompiler.StubbedClassName(cl.ToFullyQualifiedName(true), typeMapper);
var iface = new CSInterface(CSVisibility.Public, csName);
return(iface);
}
public static CSType ToCSSimpleType(NetTypeBundle ntb, CSUsingPackages use)
{
if (!String.IsNullOrEmpty(ntb.NameSpace))
{
use.AddIfNotPresent(ntb.NameSpace);
}
return(ntb.Entity == EntityType.Tuple ? ToCSTuple(ntb.TupleTypes, use) : ntb.ToCSType(use));
}
static string MangledReturnType(FunctionDeclaration func, TypeMapper mapper, CSUsingPackages use, TypeSpec ts)
{
var ntb = mapper.MapType(func, ts, false, true);
var type = NetTypeBundle.ToCSSimpleType(ntb, use);
var returnTypeName = type.ToString().Replace(".", "").Replace("<", "").Replace(">", "");
return(returnTypeName);
}
public void ArcClassStruct()
{
string swiftCode =
"public final class Foo {\npublic var _nm:String\npublic init(name:String) {\n_nm = name }\n" +
"deinit {\nprint(_nm)\n}\n}\n" +
"public struct Bar {\n public var a:Foo\n public init(f:Foo) {\n a = f\n}\n }\n"
;
swiftCode += TestRunning.CreateSwiftConsoleRedirect();
using (TempDirectoryFilenameProvider provider = new TempDirectoryFilenameProvider(null, true)) {
Utils.CompileSwift(swiftCode, provider);
string libFileName = Path.Combine(provider.DirectoryPath, "libXython.dylib");
var errors = new ErrorHandling();
ModuleInventory.FromFile(libFileName, errors);
Utils.CheckErrors(errors);
Utils.CompileToCSharp(provider);
CSUsingPackages use = new CSUsingPackages("System", "System.Runtime.InteropServices", "SwiftRuntimeLibrary");
CSNamespace ns = new CSNamespace("Xython");
CSFile csfile = CSFile.Create(use, ns);
CSIdentifier inst = new CSIdentifier("inst");
CSLine newer = CSVariableDeclaration.VarLine((CSSimpleType)"Foo", inst, CSFunctionCall.Ctor("Foo",
CSFunctionCall.Function("SwiftString.FromString", CSConstant.Val("nothing"))));
CSIdentifier inst1 = new CSIdentifier("bar");
CSLine newer1 = CSVariableDeclaration.VarLine((CSSimpleType)"Bar", inst1, CSFunctionCall.Ctor("Bar", inst));
CSLine disposer = CSFunctionCall.FunctionCallLine(inst.Name + ".Dispose", false);
CSLine disposer1 = CSFunctionCall.FunctionCallLine(inst1.Name + ".Dispose", false);
CSCodeBlock mainBody = CSCodeBlock.Create(newer, newer1, disposer, disposer1);
CSMethod main = new CSMethod(CSVisibility.Public, CSMethodKind.Static, CSSimpleType.Void,
(CSIdentifier)"Main", new CSParameterList(new CSParameter(CSSimpleType.CreateArray("string"), "args")),
mainBody);
CSClass mainClass = new CSClass(CSVisibility.Public, "NameNotImportant", new CSMethod [] { main });
ns.Block.Add(mainClass);
string csOutFilename = provider.ProvideFileFor(provider.UniqueName(null, "CSWrap", "cs"));
var exeOutFilename = provider.UniquePath(null, "CSWrap", "exe");
CodeWriter.WriteToFile(csOutFilename, csfile);
Compiler.CSCompile(provider.DirectoryPath, Directory.GetFiles(provider.DirectoryPath, "*.cs"), exeOutFilename);
TestRunning.CopyTestReferencesTo(provider.DirectoryPath);
string output = Compiler.RunWithMono(exeOutFilename, provider.DirectoryPath);
Assert.AreEqual("nothing\n", output);
}
}
public static CSSimpleType ToCSTuple(IList <NetTypeBundle> innerTypes, CSUsingPackages use)
{
if (innerTypes.Count <= 7)
{
return(new CSSimpleType("Tuple", false, ToCSSimpleType(innerTypes, use).ToArray()));
}
else
{
IEnumerable <CSType> head = ToCSSimpleType(innerTypes.Take(7), use);
CSType tail = ToCSTuple(innerTypes.Skip(7).ToList(), use);
return(new CSSimpleType("Tuple", false, Enumerable.Concat(head, Enumerable.Repeat(tail, 1)).ToArray()));
}
}
public void Compile()
{
if (verbose)
{
NewClassCompiler.ReportCompileStatus(protocols, "ObjC protocols");
}
if (!protocols.Any())
{
return;
}
var use = new CSUsingPackages("System", "ObjCRuntime", "Foundation");
string nameSpace = typeMapper.MapModuleToNamespace(module.Name);
var nm = new CSNamespace(nameSpace);
var objCClasses = ObjCClasses();
foreach (var cl in objCClasses)
{
var csIface = BuildCSIface(cl, use);
nm.Block.Add(csIface);
}
foreach (var proto in protocols)
{
if (proto.IsDeprecated || proto.IsUnavailable)
{
continue;
}
try {
var iface = CompileProtocol(proto, use);
nm.Block.Add(iface);
} catch (Exception e) {
errors.Add(e);
}
}
var csfile = new CSFile(use, new CSNamespace [] { nm });
string csOutputFileName = $"{nameSpace}ObjCProtocol.cs";
NewClassCompiler.WriteCSFile(csOutputFileName, outputDirectory, csfile);
var needsSwiftRuntimeLibrary = use.Elements.Any(elem => (elem as CSUsing).Contents.Contains("SwiftRuntimeLibrary"));
YouCantBtouchThis(csOutputFileName, needsSwiftRuntimeLibrary);
CleanUpExtraneousFiles(protocols, csOutputFileName);
}
static CSUsingPackages GetTestEntryPointUsings(string nameSpace, PlatformName platform)
{
var usings = new CSUsingPackages()
.And("System")
.And("System.IO")
.And(nameSpace)
.And("SwiftRuntimeLibrary")
.And("SwiftRuntimeLibrary.SwiftMarshal")
.And("System.Runtime.InteropServices");
if (platform != PlatformName.None)
{
usings = usings.And("Foundation");
}
return(usings);
}
static List <string> HomonymPartsFor(TLFunction func, TypeMapper mapper)
{
var parts = func.Signature.EachParameter.Select(arg => arg.Name.Name).ToList();
if (func.Signature.ReturnType == null || func.Signature.ReturnType.IsEmptyTuple)
{
parts.Add("void");
}
else
{
var use = new CSUsingPackages();
var ntb = mapper.MapType(func.Signature.ReturnType, false);
var type = NetTypeBundle.ToCSSimpleType(ntb, use);
var returnTypeName = type.ToString().Replace(".", "").Replace("<", "").Replace(">", "");
parts.Add(returnTypeName);
}
return(parts);
}
public CSType ToCSType(CSUsingPackages use)
{
if (!String.IsNullOrEmpty(NameSpace))
{
use.AddIfNotPresent(NameSpace);
}
if (IsGenericReference)
{
CSGenericReferenceType genref = new CSGenericReferenceType(GenericDepth, GenericIndex);
if (this.GenericConstraints.Count > 0)
{
genref.InterfaceConstraints.AddRange(this.GenericConstraints.Select(ntb => ntb.ToCSType(use)));
}
return(genref);
}
return(Entity == EntityType.Tuple ? ToCSTuple(TupleTypes, use) :
new CSSimpleType(Type, false, GenericTypes.Select(ntb => ntb.ToCSType(use)).ToArray()));
}
CSInterface CompileProtocol(ProtocolDeclaration proto, CSUsingPackages use)
{
var iface = new CSInterface(CSVisibility.Public, proto.Name);
kProtocolAttribute.AttachBefore(iface);
var filteredInheritance = proto.Inheritance.FindAll(inh => !TypeSpecIsAnyOrAnyObject(inh.InheritedTypeSpec));
iface.Inheritance.AddRange(filteredInheritance.Select(inh => {
var netIface = typeMapper.GetDotNetNameForTypeSpec(inh.InheritedTypeSpec);
use.AddIfNotPresent(netIface.Namespace);
return(new CSIdentifier(netIface.TypeName));
}));
foreach (var funcDecl in proto.AllMethodsNoCDTor())
{
if (funcDecl.IsProperty && !funcDecl.IsSubscript)
{
continue;
}
try {
CompileFunc(funcDecl, proto, iface, use);
} catch (Exception e) {
errors.Add(ErrorHelper.CreateWarning(ReflectorError.kWrappingBase + 14, e, $"Error compiling ObjC protocol method {proto.ToFullyQualifiedName ()}.{funcDecl.Name}"));
}
}
foreach (var propDecl in proto.AllProperties())
{
try {
CompileProp(propDecl, proto, iface, use);
} catch (Exception e) {
errors.Add(ErrorHelper.CreateWarning(ReflectorError.kWrappingBase + 14, e, $"Error compiling ObjC protocol property {proto.ToFullyQualifiedName ()}.{propDecl.Name}"));
}
}
var anyRequired = proto.AllMethodsNoCDTor().Any(func => !func.IsOptional);
if (anyRequired)
{
kAbstractAttribute.AttachBefore(iface);
}
return(iface);
}
public CSMethod CompileMethod(FunctionDeclaration func, CSUsingPackages packs, string libraryPath,
string mangledName, string functionName, bool isPinvoke, bool isFinal, bool isStatic)
{
isStatic = isStatic || func.IsExtension;
var extraProtoArgs = new CSGenericTypeDeclarationCollection();
var extraProtoConstraints = new CSGenericConstraintCollection();
var args = typeMap.MapParameterList(func, func.ParameterLists.Last(), isPinvoke, false, extraProtoArgs, extraProtoConstraints);
if (isPinvoke && func.ParameterLists.Count > 1)
{
var metaTypeBundle = new NetTypeBundle("SwiftRuntimeLibrary", "SwiftMetatype", false, false, EntityType.None);
NetParam p = new NetParam("metaClass", metaTypeBundle);
args.Add(p);
}
NetTypeBundle returnType = null;
if (func.ReturnTypeSpec is ProtocolListTypeSpec plitem && !isPinvoke)
{
returnType = new NetTypeBundle("System", "object", false, false, EntityType.ProtocolList);
}
public CSProperty CompileProperty(string propertyName, CSUsingPackages packs, SwiftType swiftPropertyType, bool hasGetter, bool hasSetter,
CSMethodKind methodKind)
{
propertyName = typeMap.SanitizeIdentifier(propertyName);
NetTypeBundle propertyType = typeMap.MapType(swiftPropertyType, false);
if (!(swiftPropertyType is SwiftGenericArgReferenceType))
{
AddUsingBlock(packs, propertyType);
}
ICodeElement [] uselessLine = new ICodeElement [] { CSReturn.ReturnLine(new CSIdentifier("useless")) };
CSCodeBlock getterBlock = null;
if (hasGetter)
{
getterBlock = new CSCodeBlock(uselessLine);
}
CSCodeBlock setterBlock = null;
if (hasSetter)
{
setterBlock = new CSCodeBlock(uselessLine);
}
CSProperty theProp = new CSProperty(propertyType.ToCSType(packs), methodKind,
new CSIdentifier(propertyName), CSVisibility.Public, getterBlock, CSVisibility.Public, setterBlock);
if (getterBlock != null)
{
getterBlock.Clear();
}
if (setterBlock != null)
{
setterBlock.Clear();
}
return(theProp);
}
public static Stream BasicClass(string nameSpace, string className, CSMethod m, ClassMutator mutator, UsingMutator useMutator = null)
{
CSUsingPackages use = new CSUsingPackages("System");
if (useMutator != null)
{
use = useMutator(use);
}
CSClass cl = new CSClass(CSVisibility.Public, className, m != null ? new CSMethod [] { m } : null);
if (mutator != null)
{
cl = mutator(cl);
}
CSNamespace ns = new CSNamespace(nameSpace);
ns.Block.Add(cl);
CSFile file = CSFile.Create(use, ns);
return(CodeWriter.WriteToStream(file));
}
public MarshalEngineCSafeSwiftToCSharp(CSUsingPackages use, List <string> identifiersUsed, TypeMapper typeMapper)
{
this.use = use;
this.typeMapper = typeMapper;
this.identifiersUsed = Ex.ThrowOnNull(identifiersUsed, "identifiersUsed");
}
static CSFile GeneratePInvokesFromTypes(TypeAggregator types, PlatformName platform, string framework)
{
var fileName = Path.GetFileNameWithoutExtension(framework); // /path/XamGlue.framework -> XamGlue
var dylibFile = Path.Combine(framework, fileName);
var funcs = TLFunctionsForFile(dylibFile, platform);
var ns = new CSNamespace("SwiftRuntimeLibrary.SwiftMarshal");
var use = new CSUsingPackages();
use.And(new CSUsing("System.Runtime.InteropServices"))
.And(new CSUsing("System"))
.And(new CSUsing("System.Collections.Generic"))
.And(new CSUsing("SwiftRuntimeLibrary"));
var csFile = new CSFile(use, new CSNamespace [] { ns });
var csClass = new CSClass(CSVisibility.Internal, $"{fileName}Metadata");
new CSComment(kRobotText).AttachBefore(use);
CSConditionalCompilation.If(PlatformToCSCondition(platform)).AttachBefore(use);
CSConditionalCompilation.Endif.AttachAfter(ns);
ns.Block.Add(csClass);
var typeOntoPinvoke = new List <KeyValuePair <CSBaseExpression, CSBaseExpression> > ();
var typesToProcess = new List <TypeDefinition> ();
typesToProcess.AddRange(types.PublicEnums);
typesToProcess.AddRange(types.PublicStructs);
// pre-sort by function name
typesToProcess.Sort((type1, type2) => String.CompareOrdinal(FuncIDForTypeDefinition(type1), FuncIDForTypeDefinition(type2)));
foreach (var type in typesToProcess)
{
if (type.HasGenericParameters)
{
continue;
}
var moduleName = type.Namespace;
var name = type.Name;
if (TypeAggregator.FilterModuleAndName(platform, moduleName, ref name))
{
var pinvoke = PInvokeForType(type, funcs);
if (pinvoke != null)
{
csClass.Methods.Add(pinvoke);
use.AddIfNotPresent(type.Namespace);
var typeOf = new CSSimpleType(type.FullName).Typeof();
var funcName = pinvoke.Name;
typeOntoPinvoke.Add(new KeyValuePair <CSBaseExpression, CSBaseExpression> (typeOf, funcName));
}
}
}
var initializers = typeOntoPinvoke.Select(typeAndFunc => new CSInitializer(new CSBaseExpression [] { typeAndFunc.Key, typeAndFunc.Value }, false));
var bindingExpr = new CSInitializedType(new CSFunctionCall("Dictionary<Type, Func<SwiftMetatype>>", true), new CSInitializer(initializers, true));
var bindingDecl = new CSFieldDeclaration(new CSSimpleType("Dictionary<Type, Func<SwiftMetatype>>"), "ObjCBindingSwiftMetatypes", bindingExpr, CSVisibility.Internal, true);
csClass.Fields.Add(new CSLine(bindingDecl));
use.Sort((package1, package2) => String.CompareOrdinal(package1.Package, package2.Package));
return(csFile);
}
/// <summary>
/// Creates a list of all types, and a hash table which is initialized on first lookup from C# type
/// to Swift types.
/// </summary>
/// <param name="types">Aggregated types, a subset of which are included</param>
/// <param name="platform">Platform targeted (typically iOS or Mac)</param>
/// <param name="namespaces">Namespaces to include</param>
/// <param name="framework">Name of framework used (typically XamGlue)</param>
/// <returns>CSFile which, when written, has function looking up in hash table as described in summary</returns>
static CSFile GenerateCSharpHashTableFromTypes(TypeAggregator types, PlatformName platform, List <string> namespaces, string framework)
{
var fileName = Path.GetFileNameWithoutExtension(framework);
var ns = new CSNamespace("SwiftRuntimeLibrary.SwiftMarshal");
var use = new CSUsingPackages();
use.And(new CSUsing("System.Runtime.InteropServices"))
.And(new CSUsing("System"))
.And(new CSUsing("System.Collections.Generic"))
.And(new CSUsing("SwiftRuntimeLibrary"));
var csFile = new CSFile(use, new CSNamespace [] { ns });
var csClass = new CSClass(CSVisibility.Internal, $"{fileName}Metadata");
new CSComment(kRobotText).AttachBefore(use);
CSConditionalCompilation.If(PlatformToCSCondition(platform)).AttachBefore(use);
CSConditionalCompilation.Endif.AttachAfter(ns);
ns.Block.Add(csClass);
// collect all possible types, filter and sort
var selectedTypes = new List <TypeDefinition> ();
selectedTypes.AddRange(types.PublicEnums);
selectedTypes.AddRange(types.PublicStructs);
selectedTypes = selectedTypes.FindAll(type => IncludeType(type, namespaces, platform));
selectedTypes.Sort((type1, type2) => String.CompareOrdinal(type1.FullName, type2.FullName));
// add used namespaces to import list, sort list
foreach (var type in selectedTypes)
{
use.AddIfNotPresent(type.Namespace);
}
use.Sort((package1, package2) => String.CompareOrdinal(package1.Package, package2.Package));
// create list of types to translate
var typesForList = selectedTypes.Select(type => new CSSimpleType(type.FullName).Typeof());
var listInitializeExpr = new CSInitializedType(
new CSFunctionCall("List<Type>", true),
new CSInitializer(typesForList, true)
);
var listBindingDecl = new CSFieldDeclaration(new CSSimpleType("List<Type>"), "csImportTypes", listInitializeExpr, CSVisibility.Internal, true);
csClass.Fields.Add(new CSLine(listBindingDecl));
// create pinvoke for function
var dylibFile = Path.Combine(framework, fileName);
var funcs = TLFunctionsForFile(dylibFile, platform);
var handleTranslationCode = new CSIdentifier(@"
public static unsafe bool GetSwiftType (Type t, out SwiftMetatype md) {
using (var swiftStr = new SwiftString (t.FullName)) {
return SwiftCore.GetEnumMetadataByName (swiftStr.SwiftData, out md);
}
}
internal static Dictionary<Type, SwiftMetatype> csImportMeta = null;
internal static bool TryGetImportedMetadata (Type cSharpType, out SwiftMetatype md) {
if (csImportMeta == null) {
csImportMeta = new Dictionary<Type, SwiftMetatype> (csImportTypes.Count);
foreach (var t in csImportTypes) {
SwiftMetatype meta;
GetSwiftType(t, out meta);
csImportMeta [t] = meta;
}
}
return csImportMeta.TryGetValue (cSharpType, out md);
}" );
csClass.Fields.Add(new CSLine(handleTranslationCode, false));
return(csFile);
}
public CSDelegateTypeDecl CompileToDelegateDeclaration(FunctionDeclaration func, CSUsingPackages packs,
string mangledName, string delegateName, bool objectsAreIntPtrs, CSVisibility vis, bool isSwiftProtocol)
{
bool returnIsGeneric = func.IsTypeSpecGeneric(func.ReturnTypeSpec);
var args = typeMap.MapParameterList(func, func.ParameterLists.Last(), objectsAreIntPtrs, true, null, null);
RemapSwiftClosureRepresensation(args);
var returnType = returnIsGeneric ? null : typeMap.MapType(func, func.ReturnTypeSpec, objectsAreIntPtrs, true);
delegateName = delegateName ?? typeMap.SanitizeIdentifier(func.Name);
args.ForEach(a => AddUsingBlock(packs, a.Type));
if (returnType != null && !returnIsGeneric)
{
AddUsingBlock(packs, returnType);
}
CSType csReturnType = returnType == null || returnType.IsVoid ? CSSimpleType.Void : returnType.ToCSType(packs);
var csParams = new CSParameterList();
for (int i = 0; i < args.Count; i++)
{
var arg = args [i];
var argIsGeneric = func.IsTypeSpecGeneric(func.ParameterLists.Last() [i].TypeSpec);
CSParameter csParam = null;
var parmType = func.ParameterLists.Last() [i].TypeSpec;
if (arg.Type.Entity == EntityType.Tuple || (!argIsGeneric && IsObjCStruct(parmType)))
{
csParam = new CSParameter(CSSimpleType.IntPtr, new CSIdentifier(arg.Name), CSParameterKind.None, null);
}
else
{
csParam = new CSParameter(arg.Type.ToCSType(packs), new CSIdentifier(arg.Name),
arg.Type.IsReference ? CSParameterKind.Ref : CSParameterKind.None, null);
}
csParams.Add(csParam);
}
if (isSwiftProtocol)
{
packs.AddIfNotPresent(typeof(SwiftExistentialContainer1));
csParams.Insert(0, new CSParameter(new CSSimpleType(typeof(SwiftExistentialContainer1)), new CSIdentifier("self"), CSParameterKind.Ref));
}
else
{
csParams.Insert(0, new CSParameter(CSSimpleType.IntPtr, new CSIdentifier("self")));
}
var retvalName = "xam_retval";
var retvalID = new CSIdentifier(retvalName);
if (func.HasThrows || returnIsGeneric || !returnType.IsVoid) // && func.Signature.ReturnType.IsStruct || func.Signature.ReturnType.IsEnum) {
{
if (func.HasThrows)
{
csParams.Insert(0, new CSParameter(CSSimpleType.IntPtr, retvalName, CSParameterKind.None));
csReturnType = CSSimpleType.Void;
}
else
{
if (!returnIsGeneric)
{
if (!(func.ReturnTypeSpec is ClosureTypeSpec))
{
Entity ent = typeMap.GetEntityForTypeSpec(func.ReturnTypeSpec);
if (ent == null && !(func.ReturnTypeSpec is ProtocolListTypeSpec))
{
throw ErrorHelper.CreateError(ReflectorError.kCompilerBase + 8, $"Unable to find entity for class {csReturnType.ToString ()}.");
}
if (ent != null && (ent.IsStructOrEnum || ent.EntityType == EntityType.Protocol))
{
csParams.Insert(0, new CSParameter(CSSimpleType.IntPtr, retvalID, CSParameterKind.None));
csReturnType = CSSimpleType.Void;
}
else if (func.ReturnTypeSpec is ProtocolListTypeSpec pl)
{
csParams.Insert(0, new CSParameter(new CSSimpleType($"SwiftExistentialContainer{pl.Protocols.Count}"), retvalID, CSParameterKind.Ref));
csReturnType = CSSimpleType.Void;
}
}
}
else
{
csParams.Insert(0, new CSParameter(CSSimpleType.IntPtr, retvalID, CSParameterKind.None));
}
}
}
return(new CSDelegateTypeDecl(vis, csReturnType, new CSIdentifier(delegateName), csParams));
}
public static CSSimpleType ToCSOptional(NetTypeBundle optType, CSUsingPackages use)
{
use.AddIfNotPresent(typeof(SwiftOptional <>));
return(new CSSimpleType("SwiftOptional", false, optType.ToCSType(use)));
}
static IEnumerable <CSType> ToCSSimpleType(IEnumerable <NetTypeBundle> ntbs, CSUsingPackages use)
{
return(ntbs.Select(ntb => ToCSSimpleType(ntb, use)));
}
void CompileProp(PropertyDeclaration propDecl, ProtocolDeclaration proto, CSInterface iface, CSUsingPackages use)
{
var getter = propDecl.GetGetter();
var setter = propDecl.GetSetter();
var publicProp = topLevelFunctionCompiler.CompileProperty(use, null, getter, setter, CSMethodKind.None);
publicProp = new CSProperty(publicProp.PropType, CSMethodKind.None, publicProp.Name,
CSVisibility.None, new CSCodeBlock(), CSVisibility.None, setter != null ? new CSCodeBlock() : null);
ExportAttribute(getter.ObjCSelector).AttachBefore(publicProp);
if (!propDecl.IsOptional)
{
kAbstractAttribute.AttachBefore(publicProp);
}
iface.Properties.Add(publicProp);
}
void CompileFunc(FunctionDeclaration funcDecl, ProtocolDeclaration proto, CSInterface iface, CSUsingPackages use)
{
var homonymSuffix = Homonyms.HomonymSuffix(funcDecl, proto.Members.OfType <FunctionDeclaration> (), typeMapper);
var publicMethod = topLevelFunctionCompiler.CompileMethod(funcDecl, use, swiftLibPath, null, null, false, false, false);
// recast with no visibility and with the homonym suffix, if any
publicMethod = new CSMethod(CSVisibility.None, CSMethodKind.Interface, publicMethod.Type,
new CSIdentifier(publicMethod.Name.Name + homonymSuffix), publicMethod.Parameters, null);
ExportAttribute(funcDecl.ObjCSelector).AttachBefore(publicMethod);
if (!funcDecl.IsOptional)
{
kAbstractAttribute.AttachBefore(publicMethod);
}
iface.Methods.Add(publicMethod);
}
public CSProperty CompileProperty(CSUsingPackages packs, string propertyName,
FunctionDeclaration getter, FunctionDeclaration setter, CSMethodKind methodKind = CSMethodKind.None)
{
var swiftPropertyType = GetPropertyType(getter, setter);
NetTypeBundle propertyType = null;
if (TypeMapper.IsCompoundProtocolListType(swiftPropertyType))
{
propertyType = new NetTypeBundle("System", "object", false, false, EntityType.ProtocolList);
}
else
{
propertyType = typeMap.MapType(getter, swiftPropertyType, false, true);
}
propertyName = propertyName ?? typeMap.SanitizeIdentifier(getter != null ? getter.PropertyName : setter.PropertyName);
bool isSubscript = getter != null ? getter.IsSubscript :
setter.IsSubscript;
if (!getter.IsTypeSpecGeneric(swiftPropertyType))
{
AddUsingBlock(packs, propertyType);
}
var uselessLine = new ICodeElement [] { CSReturn.ReturnLine(new CSIdentifier("useless")) };
CSCodeBlock getterBlock = null;
if (getter != null)
{
getterBlock = new CSCodeBlock(uselessLine);
}
CSCodeBlock setterBlock = null;
if (setter != null)
{
setterBlock = new CSCodeBlock(uselessLine);
}
CSProperty theProp = null;
if (isSubscript)
{
List <ParameterItem> swiftParms = null;
if (getter != null)
{
swiftParms = getter.ParameterLists [1];
}
else
{
swiftParms = setter.ParameterLists [1].Skip(1).ToList();
}
var args = typeMap.MapParameterList(getter, swiftParms, false, false, null, null);
args.ForEach(a => AddUsingBlock(packs, a.Type));
var csParams =
new CSParameterList(
args.Select(a =>
new CSParameter(a.Type.ToCSType(packs),
new CSIdentifier(a.Name), a.Type.IsReference ? CSParameterKind.Ref : CSParameterKind.None, null)));
theProp = new CSProperty(propertyType.ToCSType(packs), methodKind, CSVisibility.Public, getterBlock,
CSVisibility.Public, setterBlock, csParams);
}
else
{
theProp = new CSProperty(propertyType.ToCSType(packs), methodKind,
new CSIdentifier(propertyName), CSVisibility.Public, getterBlock, CSVisibility.Public, setterBlock);
}
if (getterBlock != null)
{
getterBlock.Clear();
}
if (setterBlock != null)
{
setterBlock.Clear();
}
return(theProp);
}
