public override void Init(IScriptExportManager manager)
{
m_return = CreateReturnType(manager);
m_parameters = CreateParameterTypes(manager);
if (Type.IsNested)
{
m_declaringType = manager.RetrieveType(Type.DeclaringType);
AddAsNestedDelegate();
}
}
public override void Init(IScriptExportManager manager)
{
m_declaringType = manager.RetrieveType(Method.DeclaringType);
m_returnType = manager.RetrieveType(Method.ReturnType);
m_parameters = new ScriptExportParameter[Method.Parameters.Count];
for (int i = 0; i < m_parameters.Length; i++)
{
ParameterDefinition argument = Method.Parameters[i];
m_parameters[i] = manager.RetrieveParameter(argument);
}
}
private ScriptExportType CreateReturnType(IScriptExportManager manager)
{
foreach (MethodDefinition method in Type.Methods)
{
if (method.Name == InvokeMethodName)
{
return(manager.RetrieveType(method.ReturnType));
}
}
throw new Exception($"Invoke method '{InvokeMethodName}' wasn't found");
}
private ScriptExportAttribute CreateAttribute(IScriptExportManager manager)
{
CustomAttribute attribute = GetSerializeFieldAttribute(Field);
if (attribute == null)
{
return(null);
}
else
{
return(manager.RetrieveAttribute(attribute));
}
}
public override void Init(IScriptExportManager manager)
{
m_owner = manager.RetrieveType(Type.ElementType);
List <ScriptExportType> arguments = new List <ScriptExportType>();
foreach (TypeReference argument in Type.GenericArguments)
{
ScriptExportType exportParameter = manager.RetrieveType(argument);
arguments.Add(exportParameter);
}
m_arguments = arguments.ToArray();
}
public override void Init(IScriptExportManager manager)
{
if (Definition != null && Definition.BaseType != null)
{
m_base = manager.RetrieveType(Definition.BaseType);
}
m_fields = CreateFields(manager);
if (Type.IsNested)
{
m_declaringType = manager.RetrieveType(Type.DeclaringType);
AddAsNestedType(manager);
}
}
private IReadOnlyList <ScriptExportField> CreateFields(IScriptExportManager manager)
{
if (Definition == null)
{
return(new ScriptExportField[0]);
}
List <ScriptExportField> fields = new List <ScriptExportField>();
foreach (FieldDefinition field in Definition.Fields)
{
if (field.IsPublic)
{
if (field.IsNotSerialized)
{
continue;
}
}
else
{
if (!ScriptExportMonoField.HasSerializeFieldAttribute(field))
{
continue;
}
}
if (field.FieldType.Module == null)
{
// if field has unknown type then consider it as serializable
}
else
{
TypeDefinition fieldTypeDefinition = field.FieldType.Resolve();
if (fieldTypeDefinition.IsInterface)
{
continue;
}
if (!MonoType.IsSerializableType(field.FieldType))
{
continue;
}
}
ScriptExportField efield = manager.RetrieveField(field);
fields.Add(efield);
}
return(fields.ToArray());
}
private IReadOnlyList <ScriptExportParameter> CreateParameterTypes(IScriptExportManager manager)
{
foreach (MethodDefinition method in Type.Methods)
{
if (method.Name == InvokeMethodName)
{
ScriptExportParameter[] parameters = new ScriptExportParameter[method.Parameters.Count];
for (int i = 0; i < parameters.Length; i++)
{
parameters[i] = manager.RetrieveParameter(method.Parameters[i]);
}
return(parameters);
}
}
throw new Exception($"Invoke method '{InvokeMethodName}' wasn't found");
}
private IReadOnlyList <ScriptExportField> CreateFields(IScriptExportManager manager)
{
List <ScriptExportField> fields = new List <ScriptExportField>();
foreach (FieldDefinition field in Definition.Fields)
{
if (field.Name == "value__")
{
continue;
}
ScriptExportField enumField = manager.RetrieveField(field);
fields.Add(enumField);
}
return(fields);
}
public override void Init(IScriptExportManager manager)
{
if (Type.Module == null)
{
m_fields = new ScriptExportField[0];
}
else
{
m_fields = CreateFields(manager);
}
if (Type.IsNested)
{
m_declaringType = manager.RetrieveType(Type.DeclaringType);
AddAsNestedEnum();
}
}
private IReadOnlyList <ScriptExportField> CreateFields(IScriptExportManager manager)
{
if (Definition == null)
{
return(new ScriptExportField[0]);
}
List <ScriptExportField> fields = new List <ScriptExportField>();
foreach (FieldDefinition field in Definition.Fields)
{
if (!MonoField.IsSerializableModifier(field))
{
continue;
}
if (field.FieldType.Module == null)
{
// if field has unknown type then consider it as serializable
}
else if (field.FieldType.ContainsGenericParameter)
{
// if field type has generic parameter then consider it as serializable
}
else
{
TypeDefinition definition = field.FieldType.Resolve();
if (definition == null)
{
// if field has unknown type then consider it as serializable
}
else
{
MonoSerializableScope scope = new MonoSerializableScope(field);
if (!MonoField.IsFieldTypeSerializable(scope))
{
continue;
}
}
}
ScriptExportField efield = manager.RetrieveField(field);
fields.Add(efield);
}
return(fields.ToArray());
}
private ScriptExportAttribute[] CreateAttributes(IScriptExportManager manager)
{
List <CustomAttribute> attributes = GetExportAttributes(Field);
if (attributes == null || attributes.Count == 0)
{
return(null);
}
else
{
ScriptExportAttribute[] result = new ScriptExportAttribute[attributes.Count];
for (int i = 0; i < attributes.Count; i++)
{
result[i] = manager.RetrieveAttribute(attributes[i]);
}
return(result);
}
}
public override void Init(IScriptExportManager manager)
{
if (Definition != null && Definition.BaseType != null)
{
m_base = manager.RetrieveType(Definition.BaseType);
}
m_methods = CreateMethods(manager);
m_properties = CreateProperties(manager);
m_fields = CreateFields(manager);
if (Type.IsNested)
{
m_declaringType = manager.RetrieveType(Type.DeclaringType);
if (!Type.IsGenericParameter)
{
AddAsNestedType();
}
}
}
public override void Init(IScriptExportManager manager)
{
m_type = manager.RetrieveType(Parameter.ParameterType.IsByReference ? Parameter.ParameterType.GetElementType() : Parameter.ParameterType);
}
protected void AddAsNestedType(IScriptExportManager manager)
{
DeclaringType.m_nestedTypes.Add(this);
}
public override void Init(IScriptExportManager manager)
{
m_declaringType = manager.RetrieveType(Field.DeclaringType);
m_type = manager.RetrieveType(Field.FieldType);
m_attributes = CreateAttributes(manager);
}
public override void Init(IScriptExportManager manager)
{
TypeSpecification specification = (TypeSpecification)Type;
m_element = manager.RetrieveType(specification.ElementType);
}
public abstract void Init(IScriptExportManager manager);
protected void AddAsNestedDelegate(IScriptExportManager manager)
{
DeclaringType.m_nestedDelegates.Add((ScriptExportDelegate)this);
}
protected void AddAsNestedEnum(IScriptExportManager manager)
{
DeclaringType.m_nestedEnums.Add((ScriptExportEnum)this);
}
public override void Init(IScriptExportManager manager)
{
m_type = manager.RetrieveType(Attribute.AttributeType);
}
public override void Init(IScriptExportManager manager)
{
m_declaringType = manager.RetrieveType(Property.DeclaringType);
m_type = manager.RetrieveType(Property.PropertyType);
}
public override void Init(IScriptExportManager manager)
{
m_type = manager.RetrieveType(Parameter.ParameterType);
}
private IReadOnlyList <ScriptExportProperty> CreateProperties(IScriptExportManager manager)
{
if (Definition == null || Definition.BaseType == null || Definition.BaseType.Module == null)
{
return(Array.Empty <ScriptExportProperty>());
}
// we need to export only such properties that are declared as asbtract inside builin assemblies
// and not overridden anywhere except current type
List <PropertyDefinition> overrides = new List <PropertyDefinition>();
foreach (PropertyDefinition property in Definition.Properties)
{
MethodDefinition method = property.GetMethod == null ? property.SetMethod : property.GetMethod;
if (method.IsVirtual && method.IsReuseSlot)
{
overrides.Add(property);
}
}
List <ScriptExportProperty> properties = new List <ScriptExportProperty>();
MonoTypeContext context = new MonoTypeContext(Definition);
TypeDefinition definition = Definition;
while (true)
{
if (overrides.Count == 0)
{
break;
}
if (definition.BaseType == null || definition.BaseType.Module == null)
{
break;
}
context = context.GetBase();
definition = context.Type.Resolve();
if (definition == null)
{
break;
}
string module = GetModuleName(context.Type);
bool isBuiltIn = ScriptExportManager.IsBuiltinLibrary(module);
foreach (PropertyDefinition property in definition.Properties)
{
MethodDefinition method = property.GetMethod == null ? property.SetMethod : property.GetMethod;
if (method.IsVirtual && (method.IsNewSlot || method.IsReuseSlot))
{
for (int i = 0; i < overrides.Count; i++)
{
PropertyDefinition @override = overrides[i];
if (@override.Name == property.Name)
{
if (isBuiltIn && method.IsAbstract)
{
ScriptExportProperty exportProperty = manager.RetrieveProperty(@override);
properties.Add(exportProperty);
}
overrides.RemoveAt(i);
break;
}
}
}
}
}
return(properties.ToArray());
}
private IReadOnlyList <ScriptExportMethod> CreateMethods(IScriptExportManager manager)
{
if (Definition == null || Definition.BaseType == null || Definition.BaseType.Module == null)
{
return(Array.Empty <ScriptExportMethod>());
}
// we need to export only such properties that are declared as asbtract inside builin assemblies
// and not overridden anywhere except current type
List <MethodDefinition> overrides = new List <MethodDefinition>();
foreach (MethodDefinition method in Definition.Methods)
{
if (method.IsVirtual && method.IsReuseSlot && !method.IsGetter && !method.IsSetter)
{
overrides.Add(method);
}
}
List <ScriptExportMethod> methods = new List <ScriptExportMethod>();
MonoTypeContext context = new MonoTypeContext(Definition);
TypeDefinition definition = Definition;
while (true)
{
if (overrides.Count == 0)
{
break;
}
if (definition.BaseType == null || definition.BaseType.Module == null)
{
break;
}
context = context.GetBase();
definition = context.Type.Resolve();
if (definition == null)
{
break;
}
string module = GetModuleName(definition);
bool isBuiltIn = ScriptExportManager.IsBuiltinLibrary(module);
IReadOnlyDictionary <GenericParameter, TypeReference> arguments = context.GetContextArguments();
// definition is a Template for GenericInstance, so we must recreate context
MonoTypeContext definitionContext = new MonoTypeContext(definition, arguments);
foreach (MethodDefinition method in definition.Methods)
{
if (method.IsVirtual && (method.IsNewSlot || method.IsReuseSlot))
{
for (int i = 0; i < overrides.Count; i++)
{
MethodDefinition @override = overrides[i];
if (MonoUtils.AreSame(@override, definitionContext, method))
{
if (isBuiltIn && method.IsAbstract)
{
ScriptExportMethod exportMethod = manager.RetrieveMethod(@override);
methods.Add(exportMethod);
}
overrides.RemoveAt(i);
break;
}
}
}
}
}
return(methods.ToArray());
}
