public static NSObjectProjectInfo GetProjectInfo(ProjectDom dom)
{
NSObjectProjectInfo info;
lock (infos) {
if (infos.TryGetValue(dom, out info))
{
return(info);
}
//only include DOMs that can resolve NSObject
var nso = dom.GetType(nsobjectType);
if (nso == null)
{
infos[dom] = null;
return(null);
}
info = new NSObjectProjectInfo(dom);
infos[dom] = info;
dom.Unloaded += HandleDomUnloaded;
dom.ReferencesUpdated += HandleDomReferencesUpdated;
}
return(info);
}
/// <summary>Filters out members whose names conflict with existing accessible members</summary>
/// <param name="members">Full list of CodeBehind members</param>
/// <param name="cls">The class to which these members' partial class will be added.</param>
/// <param name="designerFile">Members in this file will be ignored.</param>
/// <param name="resolveDom">The ProjectDom to use for resolving base types.</param>
/// <param name="internalDom">The ProjectDom to use for checking whether members are accessible as internal.</param>
/// <returns>The filtered list of non-conflicting members.</returns>
// TODO: check compatibilty with existing members
public static IEnumerable <CodeBehindMember> GetDesignerMembers(
IEnumerable <CodeBehindMember> members, IType cls, string designerFile, ProjectDom resolveDom,
ProjectDom internalDom)
{
var existingMembers = new HashSet <string> ();
while (cls != null)
{
foreach (var member in cls.Members)
{
if (member.IsPrivate || (member.IsInternal && member.DeclaringType.SourceProjectDom != internalDom))
{
continue;
}
if (member.DeclaringType.CompilationUnit.FileName == designerFile)
{
continue;
}
existingMembers.Add(member.Name);
}
if (cls.BaseType == null)
{
break;
}
cls = resolveDom.GetType(cls.BaseType);
}
return(members.Where(m => !existingMembers.Contains(m.Name)));
}
IMethod FindConstructor(ProjectDom dom, IAttribute att)
{
// The constructor provided by CustomAttribute.Constructor is lacking some information, such as the parameter
// name and custom attributes. Since we need the full info, we have to look it up in the declaring type.
IType atd = dom.GetType(att.AttributeType);
foreach (IMethod met in atd.Methods)
{
if (met.IsConstructor)
{
continue;
}
if (met.Parameters.Count == att.PositionalArguments.Count)
{
for (int n = met.Parameters.Count - 1; n >= 0; n--)
{
var res = Evaluate(att.PositionalArguments [n]);
if (met.Parameters[n].ReturnType.FullName != res.Type)
{
break;
}
if (n == 0)
{
return(met);
}
}
}
}
return(null);
}
protected override void GetElementCompletions(CompletionDataList list)
{
base.GetElementCompletions(list);
ProjectDom database = GetDb();
if (database == null)
{
return;
}
IType type = database.GetType("System.Windows.DependencyObject");
if (type == null)
{
return;
}
foreach (string namespc in namespaces)
{
foreach (IType t in ListControlClasses(database, namespc))
{
list.Add(t.Name, Gtk.Stock.GoForward, t.Documentation);
}
}
}
public static IEnumerable <IType> ListControlClasses(IType baseType, ProjectDom database, string namespac)
{
if (database == null)
{
yield break;
}
//return classes if they derive from system.web.ui.control
foreach (IType type in database.GetSubclasses(baseType, false, new string [] { namespac }))
{
if (!type.IsAbstract && type.IsPublic)
{
yield return(type);
}
}
if (!baseType.IsAbstract && baseType.IsPublic && baseType.Namespace == namespac)
{
IType t = database.GetType(baseType.FullName);
if (t != null)
{
yield return(baseType);
}
}
}
public override IEnumerable <object> CreateResolveResult(ProjectDom dom, IMember callingMember)
{
List <object> result = new List <object> ();
if (IsLoopVariable)
{
if (ResolvedType.Name == "IEnumerable" && ResolvedType.GenericArguments != null && ResolvedType.GenericArguments.Count > 0)
{
MemberResolveResult.AddType(dom, result, ResolvedType.GenericArguments [0], callingMember, StaticResolve);
}
else if (ResolvedType.Name == "IEnumerable")
{
MemberResolveResult.AddType(dom, result, DomReturnType.Object, callingMember, StaticResolve);
}
else
{
MemberResolveResult.AddType(dom, result, dom.GetType(ResolvedType), callingMember, StaticResolve);
}
}
else
{
MemberResolveResult.AddType(dom, result, ResolvedType, callingMember, StaticResolve);
}
return(result);
}
public Dictionary <string, IType> GetToolboxItems()
{
Dictionary <string, IType> tb_items = new Dictionary <string, IType> ();
IType wt = ctx.GetType("Gtk.Widget", true);
if (wt != null)
{
foreach (IType t in ctx.GetSubclasses(wt, true))
{
if (t.SourceProjectDom == ctx && IsToolboxWidget(t))
{
tb_items [t.FullName] = t;
}
}
}
return(tb_items);
}
IType GetFullClass(out ProjectDom ctx)
{
if (project == null || className == null)
{
ctx = null;
return(null);
}
ctx = MonoDevelop.Projects.Dom.Parser.ProjectDomService.GetProjectDom(project);
return(ctx.GetType(className, false, false));
}
static IType EnsureClassExists(ProjectDom ctx, string className, DomRegion location)
{
IType cls = ctx.GetType(className);
if (cls == null)
{
throw new TypeNotFoundException(className, location, null);
}
return(cls);
}
public override IEnumerable <object> CreateResolveResult(ProjectDom dom, IMember callingMember)
{
List <object> result = new List <object> ();
if (ResolvedExpression != null && ResolvedExpression.ExpressionContext != null && ResolvedExpression.ExpressionContext.IsObjectCreation)
{
AddType(dom, result, dom.GetType(ResolvedType), callingMember, true);
}
else
{
AddType(dom, result, ResolvedType, callingMember, StaticResolve);
}
return(result);
}
void GetCodeBehind(out IType codeBehindClass, out ProjectDom projectDatabase)
{
codeBehindClass = null;
projectDatabase = null;
if (HasDoc && !string.IsNullOrEmpty(aspDoc.Info.InheritedClass))
{
projectDatabase = ProjectDomService.GetProjectDom(project);
if (projectDatabase != null)
{
codeBehindClass = projectDatabase.GetType(aspDoc.Info.InheritedClass, false, false);
}
}
}
public void Add(ProjectDom dom, IReturnType parameterType, IReturnType type)
{
// Console.WriteLine ("Add:" + parameterType +"\n\t->" + type);
if (type == null || string.IsNullOrEmpty(type.FullName))
{
return;
}
string name = parameterType.Name;
bool contains = typeTable.ContainsKey(name);
// when the type is already in the table use the type that is more general in the inheritance tree.
if (contains && dom != null)
{
var t1 = dom.GetType(typeTable[name]);
var t2 = dom.GetType(type);
if (t1 != null && !dom.GetInheritanceTree(t1).Any(t => t.DecoratedFullName == t2.DecoratedFullName))
{
return;
}
}
DomReturnType newType = new DomReturnType(type.FullName);
newType.ArrayDimensions = Math.Max(0, type.ArrayDimensions - parameterType.ArrayDimensions);
newType.PointerNestingLevel = Math.Max(0, type.PointerNestingLevel - parameterType.PointerNestingLevel);
newType.Type = type.Type; // May be anonymous type
for (int i = 0; i < newType.ArrayDimensions; i++)
{
newType.SetDimension(i, parameterType.GetDimension(i));
}
foreach (var generic in type.GenericArguments)
{
newType.AddTypeParameter(generic);
}
typeTable[name] = newType;
}
public void SimpleGetType()
{
// Simple get
IType type = mainProject.GetType("CompletionDbTest.MainClass");
Assert.IsNotNull(type);
Assert.AreEqual("CompletionDbTest.MainClass", type.FullName);
// Deep search in local project
type = mainProject.GetType("CompletionDbTest.MainClass", true);
Assert.IsNotNull(type);
Assert.AreEqual("CompletionDbTest.MainClass", type.FullName);
// Non deep search
// FIXME: deep search is currently the same as non-deep-search
// type = mainProject.GetType ("Library2.CWidget", false);
// Assert.IsNull (type);
// Deep search by default
type = mainProject.GetType("Library2.CWidget");
Assert.IsNotNull(type);
Assert.AreEqual("Library2.CWidget", type.FullName);
//check that references are accessible, but not references of references
type = mainProject.GetType("Library3.Lib3Class");
Assert.IsNull(type);
type = lib2.GetType("Library3.Lib3Class");
Assert.IsNotNull(type);
// Deep insensitive
type = mainProject.GetType("library2.cwidget", true, false);
Assert.IsNotNull(type);
Assert.AreEqual("Library2.CWidget", type.FullName);
// Case sensitive
type = mainProject.GetType("library2.cwidget", true, true);
Assert.IsNull(type);
// Not generic
type = mainProject.GetType("CompletionDbTest.MainClass", 1, true);
Assert.IsNull(type);
// System.Object
type = mainProject.GetType("System.Object", true, true);
Assert.IsNotNull(type);
Assert.AreEqual("System.Object", type.FullName);
}
public static IReturnType GetComponentType(ProjectDom dom, IReturnType returnType)
{
if (dom == null || returnType == null)
{
return(null);
}
if (returnType.FullName == DomReturnType.String.FullName && returnType.ArrayDimensions == 0)
{
return(DomReturnType.Char);
}
if (returnType.ArrayDimensions > 0)
{
return(new DomReturnType(returnType.FullName));
}
IType resolvedType = dom.GetType(returnType);
if (resolvedType != null)
{
foreach (IType curType in dom.GetInheritanceTree(resolvedType))
{
foreach (IReturnType baseType in curType.BaseTypes)
{
if (baseType.FullName == "System.Collections.Generic.IEnumerable" && baseType.GenericArguments.Count == 1)
{
return(baseType.GenericArguments [0]);
}
}
foreach (IProperty property in curType.Properties)
{
if (property.IsIndexer && !property.IsExplicitDeclaration)
{
return(property.ReturnType);
}
}
}
}
if (returnType.GenericArguments.Count > 0)
{
return(returnType.GenericArguments [0]);
}
return(null);
}
void GetType(IAttributedXObject attributedOb, Action <IType, ProjectDom> action)
{
ProjectDom database = GetDb();
if (database == null)
{
return;
}
foreach (string namespc in namespaces)
{
IType controlType = database.GetType(namespc + "." + attributedOb.Name.Name);
if (controlType != null)
{
action(controlType, database);
break;
}
}
}
protected override SourceCodeLocation GetSourceCodeLocation(string fullClassName, string methodName)
{
ProjectDom ctx = ProjectDomService.GetProjectDom(project);
IType cls = ctx.GetType(fullClassName);
if (cls == null)
{
return(null);
}
foreach (IMethod met in cls.Methods)
{
if (met.Name == methodName)
{
return(new SourceCodeLocation(cls.CompilationUnit.FileName, met.Location.Line, met.Location.Column));
}
}
return(new SourceCodeLocation(cls.CompilationUnit.FileName, cls.Location.Line, cls.Location.Column));
}
internal bool IsValidClass(ProjectDom ctx, IType cls)
{
if (cls.BaseTypes != null)
{
foreach (IReturnType bt in cls.BaseTypes)
{
if (bt.FullName == rootWidget.Component.Type.ClassName)
{
return(true);
}
IType baseCls = ctx.GetType(bt);
if (baseCls != null && IsValidClass(ctx, baseCls))
{
return(true);
}
}
}
return(false);
}
bool IsSubclass(ProjectDom ctx, IType baseClass, IType subclass)
{
foreach (IReturnType clsName in subclass.BaseTypes)
{
if (clsName.FullName == baseClass.FullName)
{
return(true);
}
}
foreach (IReturnType clsName in subclass.BaseTypes)
{
IType cls = ctx.GetType(clsName);
if (cls != null && IsSubclass(ctx, baseClass, cls))
{
return(true);
}
}
return(false);
}
IEnumerable <NSObjectTypeInfo> GetRegisteredObjects(ProjectDom dom)
{
var nso = dom.GetType(nsobjectType);
if (nso == null)
{
throw new Exception("Could not get NSObject from type database");
}
yield return(new NSObjectTypeInfo("NSObject", nsobjectType.FullName, null, null, false));
foreach (var type in dom.GetSubclasses(nso, true))
{
var info = ConvertType(dom, type);
if (info != null)
{
yield return(info);
}
}
}
internal static bool IsValidClass(ProjectDom ctx, IType cls)
{
if (cls.BaseTypes != null)
{
foreach (IReturnType bt in cls.BaseTypes)
{
if (bt.FullName == "Gtk.ActionGroup")
{
return(true);
}
IType baseCls = ctx.GetType(bt);
if (baseCls != null && IsValidClass(ctx, baseCls))
{
return(true);
}
}
}
return(false);
}
public static IMethod GetMethodSignature(ProjectDom context, IEvent ev)
{
if (ev.ReturnType == null)
{
return(null);
}
IType cls = context.GetType(ev.ReturnType);
if (cls == null)
{
return(null);
}
foreach (IMethod m in cls.Methods)
{
if (m.Name == "Invoke")
{
return(m);
}
}
return(null);
}
void FillClasses(MoonlightProject project)
{
if (classesFilled)
{
return;
}
classesFilled = true;
try {
ProjectDom dom = ProjectDomService.GetProjectDom(project);
IType appType = dom.GetType("System.Windows.Application", true);
if (appType == null)
{
return;
}
foreach (IType type in dom.GetSubclasses(appType, false))
{
classListStore.AppendValues(type.FullName);
}
} catch (InvalidOperationException) {
// Project not found in parser database
}
}
internal static void AddType(ProjectDom dom, List <object> result, IReturnType returnType, IMember callingMember, bool showStatic)
{
if (returnType == null || returnType.FullName == "System.Void")
{
return;
}
if (returnType.ArrayDimensions > 0)
{
DomReturnType elementType = new DomReturnType(returnType.FullName);
elementType.ArrayDimensions = returnType.ArrayDimensions - 1;
for (int i = 0; i < elementType.ArrayDimensions; i++)
{
elementType.SetDimension(i, returnType.ArrayDimensions - 1);
}
elementType.PointerNestingLevel = returnType.PointerNestingLevel;
AddType(dom, result, dom.GetArrayType(elementType), callingMember, showStatic);
return;
}
IType type = dom.GetType(returnType);
AddType(dom, result, type, callingMember, showStatic);
}
static bool IsValidClass(ProjectDom ctx, IType cls, Stetic.Component obj)
{
if (cls.BaseTypes != null)
{
string typeName = obj.Type.ClassName;
foreach (IReturnType bt in cls.BaseTypes)
{
System.Console.WriteLine("tn:" + typeName + " bt:" + bt.FullName);
if (bt.FullName == typeName)
{
return(true);
}
IType baseCls = ctx.GetType(bt);
if (baseCls != null && IsValidClass(ctx, baseCls, obj))
{
return(true);
}
}
}
return(false);
}
void FindOverridables(ProjectDom pctx, IType motherClass, IType cls, List <IMember> classMembers, List <IMember> interfaceMembers, List <IType> visited, bool includeOverridenClassMembers, bool includeOverridenInterfaceMembers)
{
if (visited.Contains(cls))
{
return;
}
visited.Add(cls);
foreach (IReturnType rt in cls.BaseTypes)
{
IType baseCls = pctx.GetType(rt);
if (baseCls == null)
{
continue;
}
if (visited.Contains(baseCls))
{
continue;
}
bool isInterface = baseCls.ClassType == ClassType.Interface;
if (isInterface && interfaceMembers == null)
{
continue;
}
List <IMember> list = isInterface ? interfaceMembers : classMembers;
bool includeOverriden = isInterface ? includeOverridenInterfaceMembers : includeOverridenClassMembers;
foreach (IMethod m in baseCls.Methods)
{
if (m.IsInternal && motherClass.SourceProject != null && motherClass.SourceProject != m.DeclaringType.SourceProject)
{
continue;
}
if ((isInterface || m.IsVirtual || m.IsAbstract) && !m.IsSpecialName && !m.IsSealed && (includeOverriden || !IsOverridenMethod(motherClass, m)))
{
list.Add(m);
}
}
foreach (IProperty m in baseCls.Properties)
{
if (m.IsIndexer)
{
continue;
}
if (m.IsInternal && motherClass.SourceProject != null && motherClass.SourceProject != m.DeclaringType.SourceProject)
{
continue;
}
if ((isInterface || m.IsVirtual || m.IsAbstract) && !m.IsSpecialName && !m.IsSealed && (includeOverriden || !IsOverridenProperty(motherClass, m)))
{
list.Add(m);
}
}
foreach (IProperty m in baseCls.Properties)
{
if (!m.IsIndexer)
{
continue;
}
if (m.IsInternal && motherClass.SourceProject != null && motherClass.SourceProject != m.DeclaringType.SourceProject)
{
continue;
}
if ((isInterface || m.IsVirtual || m.IsAbstract) && !m.IsSpecialName && !m.IsSealed && (includeOverriden || !IsOverridenIndexer(motherClass, m)))
{
list.Add(m);
}
}
foreach (IEvent m in baseCls.Events)
{
if (m.IsInternal && motherClass.SourceProject != null && motherClass.SourceProject != m.DeclaringType.SourceProject)
{
continue;
}
if ((isInterface || m.IsVirtual || m.IsAbstract) && !m.IsSpecialName && !m.IsSealed)
{
list.Add(m);
}
}
FindOverridables(pctx, motherClass, baseCls, classMembers, isInterface ? interfaceMembers : null, visited,
includeOverridenClassMembers, includeOverridenInterfaceMembers);
}
}
//TODO: check accessibility
public static IEnumerable <IMethod> GetCompatibleMethodsInClass(ProjectDom ctx, IType cls, IMethod matchMeth)
{
IList <IType>[] pars = new IList <IType> [matchMeth.Parameters.Count];
for (int i = 0; i < matchMeth.Parameters.Count; i++)
{
IType t = ctx.GetType(matchMeth.Parameters[i].ReturnType);
if (t != null)
{
pars[i] = new List <IType> (ctx.GetInheritanceTree(t));
}
else
{
pars[i] = new IType[0];
}
}
foreach (IType type in ctx.GetInheritanceTree(cls))
{
if (type.ClassType != ClassType.Class)
{
continue;
}
foreach (IMethod method in type.Methods)
{
if (method.IsPrivate || method.Parameters.Count != pars.Length || method.ReturnType.FullName != matchMeth.ReturnType.FullName
|| method.IsInternal)
{
continue;
}
bool allCompatible = true;
//compare each parameter
for (int i = 0; i < pars.Length; i++)
{
bool parCompatible = false;
foreach (IType t in pars[i])
{
if (t.FullName == method.Parameters[i].ReturnType.FullName)
{
parCompatible = true;
break;
}
}
if (!parCompatible)
{
allCompatible = false;
break;
}
}
if (allCompatible)
{
yield return(method);
}
}
}
}
public static IMember GetCompatibleMemberInClass(ProjectDom ctx, IType cls, CodeTypeMember member)
{
//check for identical property names
foreach (IProperty prop in cls.Properties)
{
if (string.Compare(prop.Name, member.Name, StringComparison.OrdinalIgnoreCase) == 0)
{
EnsureClassExists(ctx, prop.ReturnType.FullName, GetValidRegion(prop));
CodeMemberProperty memProp = member as CodeMemberProperty;
if (memProp == null || !IsTypeCompatible(ctx, prop.ReturnType.FullName, memProp.Type.BaseType))
{
throw new MemberExistsException(cls.FullName, MemberType.Property, member, GetValidRegion(prop), cls.CompilationUnit.FileName);
}
return(prop);
}
}
//check for identical method names
foreach (IMethod meth in cls.Methods)
{
if (string.Compare(meth.Name, member.Name, StringComparison.OrdinalIgnoreCase) == 0)
{
EnsureClassExists(ctx, meth.ReturnType.FullName, GetValidRegion(meth));
CodeMemberMethod memMeth = member as CodeMemberMethod;
if (memMeth == null || !IsTypeCompatible(ctx, meth.ReturnType.FullName, memMeth.ReturnType.BaseType))
{
throw new MemberExistsException(cls.FullName, MemberType.Method, member, GetValidRegion(meth), cls.CompilationUnit.FileName);
}
return(meth);
}
}
//check for identical event names
foreach (IEvent ev in cls.Events)
{
if (string.Compare(ev.Name, member.Name, StringComparison.OrdinalIgnoreCase) == 0)
{
EnsureClassExists(ctx, ev.ReturnType.FullName, GetValidRegion(ev));
CodeMemberEvent memEv = member as CodeMemberEvent;
if (memEv == null || !IsTypeCompatible(ctx, ev.ReturnType.FullName, memEv.Type.BaseType))
{
throw new MemberExistsException(cls.FullName, MemberType.Event, member, GetValidRegion(ev), cls.CompilationUnit.FileName);
}
return(ev);
}
}
//check for identical field names
foreach (IField field in cls.Fields)
{
if (string.Compare(field.Name, member.Name, StringComparison.OrdinalIgnoreCase) == 0)
{
EnsureClassExists(ctx, field.ReturnType.FullName, GetValidRegion(field));
CodeMemberField memField = member as CodeMemberField;
if (memField == null || !IsTypeCompatible(ctx, field.ReturnType.FullName, memField.Type.BaseType))
{
throw new MemberExistsException(cls.FullName, MemberType.Field, member, GetValidRegion(field), cls.CompilationUnit.FileName);
}
return(field);
}
}
//walk down into base classes, if any
foreach (IReturnType baseType in cls.BaseTypes)
{
IType c = ctx.GetType(baseType);
if (c == null)
{
throw new TypeNotFoundException(baseType.FullName, cls.BodyRegion, cls.CompilationUnit.FileName);
}
IMember mem = GetCompatibleMemberInClass(ctx, c, member);
if (mem != null)
{
return(mem);
}
}
//return null if no match
return(null);
}
void Refactor(IProgressMonitor monitor, IType cls, RefactoryScope scope, RefactorDelegate refactorDelegate)
{
switch (scope)
{
case RefactoryScope.DeclaringType:
ProjectDom ctx = GetParserContext(cls);
if (cls is InstantiatedType)
{
cls = ((InstantiatedType)cls).UninstantiatedType;
}
IType resolvedType = ctx.GetType(cls.FullName, cls.TypeParameters.Count, true, true);
if (resolvedType == null)
{
goto case RefactoryScope.Solution;
}
foreach (IType part in resolvedType.Parts)
{
string file = part.CompilationUnit.FileName;
RefactorerContext gctx = GetGeneratorContext(part);
IRefactorer gen = LanguageBindingService.GetRefactorerForFile(file);
if (gen == null)
{
return;
}
refactorDelegate(monitor, gctx, gen, file);
gctx.Save();
}
break;
case RefactoryScope.File: {
string file = cls.CompilationUnit.FileName;
RefactorerContext gctx = GetGeneratorContext(cls);
IRefactorer gen = LanguageBindingService.GetRefactorerForFile(file);
if (gen == null)
{
return;
}
refactorDelegate(monitor, gctx, gen, file);
gctx.Save();
break;
}
case RefactoryScope.Project:
Project prj = GetProjectForFile(cls.CompilationUnit.FileName);
if (prj == null)
{
return;
}
RefactorProject(monitor, prj, refactorDelegate);
break;
case RefactoryScope.Solution:
if (solution == null)
{
goto case RefactoryScope.File;
}
foreach (Project project in solution.GetAllProjects())
{
RefactorProject(monitor, project, refactorDelegate);
}
break;
}
}
public static IType AssemblyTypeLookup(ProjectDom assemblyDatabase, string namespac, string tagName)
{
return((assemblyDatabase == null)
? null
: assemblyDatabase.GetType(namespac + "." + tagName, false, false));
}
/// <summary>
/// Resolves the Objective-C types by mapping the known .NET type information.
/// </summary>
/// <param name='type'>
/// An NSObjectTypeInfo with the .NET type information filled in.
/// </param>
public void ResolveCliToObjc(NSObjectTypeInfo type)
{
NSObjectTypeInfo resolved;
if (type.BaseObjCType == null && type.BaseCliType != null)
{
if (TryResolveCliToObjc(type.BaseCliType, out resolved))
{
if (resolved.IsModel)
{
type.BaseIsModel = true;
}
type.BaseObjCType = resolved.ObjCName;
//FIXME: handle type references better
if (resolved.IsUserType)
{
type.UserTypeReferences.Add(resolved.ObjCName);
}
}
else
{
// managed classes may have implicitly registered base classes with a name not
// expressible in obj-c. In this case, the best we can do is walk down the
// hierarchy until we find a valid base class
foreach (var bt in dom.GetInheritanceTree(dom.GetType(type.BaseCliType)))
{
if (bt.ClassType != ClassType.Class)
{
continue;
}
if (TryResolveCliToObjc(bt.FullName, out resolved))
{
if (resolved.IsModel)
{
type.BaseIsModel = true;
}
type.BaseObjCType = resolved.ObjCName;
if (resolved.IsUserType)
{
type.UserTypeReferences.Add(resolved.ObjCName);
}
break;
}
}
}
}
foreach (var outlet in type.Outlets)
{
if (outlet.ObjCType != null)
{
continue;
}
if (TryResolveCliToObjc(outlet.CliType, out resolved))
{
outlet.ObjCType = resolved.ObjCName;
if (resolved.IsUserType)
{
type.UserTypeReferences.Add(resolved.ObjCName);
}
}
}
foreach (var action in type.Actions)
{
foreach (var param in action.Parameters)
{
if (param.ObjCType != null)
{
continue;
}
if (TryResolveCliToObjc(param.CliType, out resolved))
{
param.ObjCType = resolved.ObjCName;
if (resolved.IsUserType)
{
type.UserTypeReferences.Add(resolved.ObjCName);
}
}
}
}
}