public MetadataGenerationError(MetadataType metadataType, Type type, string errorReason, string sugestionedSolution)
{
MetadataType = metadataType;
Type = type;
ErrorReason = errorReason;
SuggestedSolution = sugestionedSolution;
}
public MetadataCheckBox(MetadataType metadataType, string displayText, string count, string ignoredCount)
: this(metadataType, displayText, count)
{
lblIgnoredFields.Text = "( Excluded " + ignoredCount + " fields )";
lblIgnoredFields.Visible = true;
MetadataType = metadataType;
}
/// <summary>
/// PeerEventArgs Constructor
/// </summary>
/// <param name="parsed">a simple MessageParse</param>
internal PeerEventArgs(dynamic parsed)
{
#if DEBUG
FCP2Protocol.ArgsDebug(this, parsed);
#endif
lastGoodVersion = parsed.lastGoodVersion;
opennet = parsed.opennet;
myName = parsed.myName;
identity = parsed.identity;
location = parsed.location;
testnet = parsed.testnet;
version = parsed.version;
physical = new PhysicalType(parsed);
ark = new ArkType(parsed);
dsaPubKey = new DsaPubKeyType(parsed);
dsaGroup = new DsaGroupType(parsed);
auth = new AuthType(parsed);
@volatile = new VolatileType(parsed);
metadata = new MetadataType(parsed);
#if DEBUG
parsed.PrintAccessCount();
#endif
}
/// <summary>
/// PeerEventArgs Constructor
/// </summary>
/// <param name="parsed">a simple MessageParse</param>
internal PeerEventArgs(dynamic parsed)
{
#if DEBUG
FCP2Protocol.ArgsDebug(this, parsed);
#endif
LastGoodVersion = parsed.lastGoodVersion;
Opennet = parsed.opennet;
MyName = parsed.myName;
Identity = parsed.identity;
Location = parsed.location;
Testnet = parsed.testnet;
Version = parsed.version;
Physical = new PhysicalType(parsed);
Ark = new ArkType(parsed);
DsaPubKey = new DsaPubKeyType(parsed);
DsaGroup = new DsaGroupType(parsed);
Auth = new AuthType(parsed);
Volatile = new VolatileType(parsed);
Metadata = new MetadataType(parsed);
#if DEBUG
parsed.PrintAccessCount();
#endif
}
public static void GetTableName(MetadataType type, out string tableName, out string keyFieldName)
{
tableName = string.Empty;
keyFieldName = "Id";
switch (type)
{
case MetadataType.QuotationSource:
tableName = "QuotationSource";
break;
case MetadataType.Instrument:
tableName = "Instrument";
break;
case MetadataType.InstrumentSourceRelation:
tableName = "InstrumentSourceRelation";
break;
case MetadataType.DerivativeRelation:
tableName = "DerivativeRelation";
keyFieldName = "InstrumentId";
break;
case MetadataType.PriceRangeCheckRule:
tableName = "PriceRangeCheckRule";
keyFieldName = "InstrumentId";
break;
case MetadataType.WeightedPriceRule:
tableName = "WeightedPriceRule";
keyFieldName = "InstrumentId";
break;
}
}
public override IEnumerable<string> GetMetadata(MetadataType type)
{
if (parsedFile.Metadata.ContainsKey(type))
return parsedFile.Metadata[type];
return null;
}
public static bool IsSupportedRiskElements(FileType fileType, MetadataType metadatatype)
{
if (metadatatype == MetadataType.Hyperlink && OptionApi.GetBool(SharedRibbon.Library.Options.ExcludeFieldCodesHyperlinks))
return false;
if (IsExcel(fileType))
{
switch (metadatatype)
{
case MetadataType.SmallText:
case MetadataType.WhiteText:
case MetadataType.HiddenText:
return false;
default:
return true;
}
}
if (IsWord(fileType))
{
switch (metadatatype)
{
case MetadataType.Hyperlink:
{
return false;
}
}
}
return true;
}
internal MetadataPropertyInfo (IMetadataImport importer, int propertyToken, MetadataType declaringType)
{
m_importer = importer;
m_propertyToken = propertyToken;
m_declaringType = declaringType;
int mdTypeDef;
int pchProperty;
int pdwPropFlags;
IntPtr ppvSig;
int pbSig;
int pdwCPlusTypeFlag;
IntPtr ppDefaultValue;
int pcchDefaultValue;
int rmdOtherMethod;
int pcOtherMethod;
m_importer.GetPropertyProps (
m_propertyToken,
out mdTypeDef,
null,
0,
out pchProperty,
out pdwPropFlags,
out ppvSig,
out pbSig,
out pdwCPlusTypeFlag,
out ppDefaultValue,
out pcchDefaultValue,
out m_pmdSetter,
out m_pmdGetter,
out rmdOtherMethod,
0,
out pcOtherMethod);
StringBuilder szProperty = new StringBuilder (pchProperty);
m_importer.GetPropertyProps (
m_propertyToken,
out mdTypeDef,
szProperty,
pchProperty,
out pchProperty,
out pdwPropFlags,
out ppvSig,
out pbSig,
out pdwCPlusTypeFlag,
out ppDefaultValue,
out pcchDefaultValue,
out m_pmdSetter,
out m_pmdGetter,
out rmdOtherMethod,
0,
out pcOtherMethod);
m_propAttributes = (PropertyAttributes) pdwPropFlags;
m_name = szProperty.ToString ();
MetadataHelperFunctions.GetCustomAttribute (importer, propertyToken, typeof (System.Diagnostics.DebuggerBrowsableAttribute));
}
public static string GetParamType(this MetadataPropertyType prop, MetadataType type, Operation op)
{
if (prop.ParamType != null)
return prop.ParamType;
var isRequest = type.Name == op.RequestType.Name;
return !isRequest ? "form" : GetRequestParamType(op, prop.Name);
}
private static object ParseDefaultValue(MetadataType declaringType, IntPtr ppvSigBlob, IntPtr ppvRawValue)
{
IntPtr ppvSigTemp = ppvSigBlob;
CorCallingConvention callingConv = MetadataHelperFunctions.CorSigUncompressCallingConv(ref ppvSigTemp);
Debug.Assert(callingConv == CorCallingConvention.Field);
CorElementType elementType = MetadataHelperFunctions.CorSigUncompressElementType(ref ppvSigTemp);
if (elementType == CorElementType.ELEMENT_TYPE_VALUETYPE)
{
uint token = MetadataHelperFunctions.CorSigUncompressToken(ref ppvSigTemp);
if (token == declaringType.MetadataToken)
{
// Static literal field of the same type as the enclosing type
// may be one of the value fields of an enum
if (declaringType.ReallyIsEnum)
{
// If so, the value will be of the enum's underlying type,
// so we change it from VALUETYPE to be that type so that
// the following code will get the value
elementType = declaringType.EnumUnderlyingType;
}
}
}
switch (elementType)
{
case CorElementType.ELEMENT_TYPE_CHAR:
return (char)Marshal.ReadByte(ppvRawValue);
case CorElementType.ELEMENT_TYPE_I1:
return (sbyte)Marshal.ReadByte(ppvRawValue);
case CorElementType.ELEMENT_TYPE_U1:
return Marshal.ReadByte(ppvRawValue);
case CorElementType.ELEMENT_TYPE_I2:
return Marshal.ReadInt16(ppvRawValue);
case CorElementType.ELEMENT_TYPE_U2:
return (ushort)Marshal.ReadInt16(ppvRawValue);
case CorElementType.ELEMENT_TYPE_I4:
return Marshal.ReadInt32(ppvRawValue);
case CorElementType.ELEMENT_TYPE_U4:
return (uint)Marshal.ReadInt32(ppvRawValue);
case CorElementType.ELEMENT_TYPE_I8:
return Marshal.ReadInt64(ppvRawValue);
case CorElementType.ELEMENT_TYPE_U8:
return (ulong)Marshal.ReadInt64(ppvRawValue);
case CorElementType.ELEMENT_TYPE_I:
return Marshal.ReadIntPtr(ppvRawValue);
case CorElementType.ELEMENT_TYPE_U:
case CorElementType.ELEMENT_TYPE_R4:
case CorElementType.ELEMENT_TYPE_R8:
// Technically U and the floating-point ones are options in the CLI, but not in the CLS or C#, so these are NYI
default:
return null;
}
}
internal static MetadataField makeMetadataField(string description, string name, MetadataType type, int pos, string format, Guid guid)
{
MetadataField metadataField = new MetadataField();
metadataField.Description = description;
metadataField.Name = name;
metadataField.Type = type;
metadataField.Guid = guid;
metadataField.DisplayPosition = pos;
metadataField.DisplayFormat = format;
return metadataField;
}
public void AddProperties(StringBuilderWrapper sb, MetadataType type, bool includeResponseStatus)
{
var makeExtensible = Config.MakeDataContractsExtensible && type.Inherits == null;
var wasAdded = false;
var dataMemberIndex = 1;
if (type.Properties != null)
{
foreach (var prop in type.Properties)
{
if (wasAdded) sb.AppendLine();
var propType = Type(prop.Type, prop.GenericArgs);
wasAdded = AppendComments(sb, prop.Description);
wasAdded = AppendDataMember(sb, prop.DataMember, dataMemberIndex++) || wasAdded;
wasAdded = AppendAttributes(sb, prop.Attributes) || wasAdded;
if (!type.IsInterface())
{
sb.AppendLine("member val {1}:{0} = {2} with get,set".Fmt(
propType, prop.Name.SafeToken(), GetDefaultLiteral(prop, type)));
}
else
{
sb.AppendLine("abstract {1}:{0} with get,set".Fmt(
propType, prop.Name.SafeToken()));
}
}
}
if (type.IsInterface())
return;
if (includeResponseStatus)
{
if (wasAdded) sb.AppendLine();
wasAdded = true;
AppendDataMember(sb, null, dataMemberIndex++);
sb.AppendLine("member val ResponseStatus:ResponseStatus = null with get,set");
}
if (makeExtensible
&& (type.Properties == null
|| type.Properties.All(x => x.Name != "ExtensionData")))
{
if (wasAdded) sb.AppendLine();
wasAdded = true;
sb.AppendLine("member val ExtensionData:ExtensionDataObject = null with get,set");
}
}
/// <summary>
/// ExpectedMIMEEventArgs Constructor
/// </summary>
/// <param name="parsed">a simple MessageParse</param>
internal ExpectedMimeEventArgs(dynamic parsed)
{
#if DEBUG
FCP2Protocol.ArgsDebug(this, parsed);
#endif
identifier = parsed.identifier;
global = parsed.global;
metadata = new MetadataType(parsed);
#if DEBUG
parsed.PrintAccessCount();
#endif
}
public void SubmitChange(MetadataType metadataType, string filed, object value)
{
ConsoleClient.Instance.UpdateMetadataObjectField(metadataType, this._MetadataObject.Id, filed, value, delegate(bool success)
{
if (success)
{
this.ApplyChangeToUI(filed, value);
}
else
{
base.OnPropertyChanged(filed);
}
});
}
public void AddProperties(StringBuilderWrapper sb, MetadataType type, bool includeResponseStatus)
{
var makeExtensible = Config.MakeDataContractsExtensible && type.Inherits == null;
var @virtual = Config.MakeVirtual && !type.IsInterface() ? "Overridable " : "";
var wasAdded = false;
var dataMemberIndex = 1;
if (type.Properties != null)
{
foreach (var prop in type.Properties)
{
if (wasAdded) sb.AppendLine();
var propType = Type(prop.Type, prop.GenericArgs, includeNested:true);
wasAdded = AppendComments(sb, prop.Description);
wasAdded = AppendDataMember(sb, prop.DataMember, dataMemberIndex++) || wasAdded;
wasAdded = AppendAttributes(sb, prop.Attributes) || wasAdded;
var visibility = type.IsInterface() ? "" : "Public ";
sb.AppendLine("{0}{1}Property {2} As {3}".Fmt(
visibility,
@virtual,
EscapeKeyword(prop.Name).SafeToken(),
propType));
}
}
if (type.IsInterface())
return;
if (includeResponseStatus)
{
if (wasAdded) sb.AppendLine();
wasAdded = true;
wasAdded = AppendDataMember(sb, null, dataMemberIndex++);
sb.AppendLine("Public {0}Property ResponseStatus As ResponseStatus".Fmt(@virtual));
}
if (makeExtensible
&& (type.Properties == null
|| type.Properties.All(x => x.Name != "ExtensionData")))
{
if (wasAdded) sb.AppendLine();
wasAdded = true;
sb.AppendLine("Public {0}Property ExtensionData As ExtensionDataObject Implements IExtensibleDataObject.ExtensionData".Fmt(@virtual));
}
}
internal MetadataFieldInfo(IMetadataImport importer,int fieldToken, MetadataType declaringType)
{
m_importer = importer;
m_fieldToken = fieldToken;
m_declaringType = declaringType;
// Initialize
int mdTypeDef;
int pchField,pcbSigBlob,pdwCPlusTypeFlab,pcchValue, pdwAttr;
IntPtr ppvSigBlob;
IntPtr ppvRawValue;
m_importer.GetFieldProps(m_fieldToken,
out mdTypeDef,
null,
0,
out pchField,
out pdwAttr,
out ppvSigBlob,
out pcbSigBlob,
out pdwCPlusTypeFlab,
out ppvRawValue,
out pcchValue
);
StringBuilder szField = new StringBuilder(pchField);
m_importer.GetFieldProps(m_fieldToken,
out mdTypeDef,
szField,
szField.Capacity,
out pchField,
out pdwAttr,
out ppvSigBlob,
out pcbSigBlob,
out pdwCPlusTypeFlab,
out ppvRawValue,
out pcchValue
);
m_fieldAttributes = (FieldAttributes)pdwAttr;
m_name = szField.ToString();
// Get the values for static literal fields with primitive types
FieldAttributes staticLiteralField = FieldAttributes.Static | FieldAttributes.HasDefault | FieldAttributes.Literal;
if ((m_fieldAttributes & staticLiteralField) == staticLiteralField)
{
m_value = ParseDefaultValue(declaringType,ppvSigBlob,ppvRawValue);
}
// [Xamarin] Expression evaluator.
MetadataHelperFunctions.GetCustomAttribute (importer, m_fieldToken, typeof (System.Diagnostics.DebuggerBrowsableAttribute));
}
internal MetadataFieldInfo(IMetadataImport importer, int fieldToken, MetadataType declaringType)
{
m_importer = importer;
m_fieldToken = fieldToken;
m_declaringType = declaringType;
// Initialize
int mdTypeDef;
int pchField, pcbSigBlob, pdwCPlusTypeFlab, pcchValue, pdwAttr;
IntPtr ppvSigBlob;
IntPtr ppvRawValue;
m_importer.GetFieldProps(m_fieldToken,
out mdTypeDef,
null,
0,
out pchField,
out pdwAttr,
out ppvSigBlob,
out pcbSigBlob,
out pdwCPlusTypeFlab,
out ppvRawValue,
out pcchValue
);
var szField = new StringBuilder(pchField);
m_importer.GetFieldProps(m_fieldToken,
out mdTypeDef,
szField,
szField.Capacity,
out pchField,
out pdwAttr,
out ppvSigBlob,
out pcbSigBlob,
out pdwCPlusTypeFlab,
out ppvRawValue,
out pcchValue
);
m_fieldAttributes = (FieldAttributes) pdwAttr;
m_name = szField.ToString();
// Get the values for static literal fields with primitive types
FieldAttributes staticLiteralField = FieldAttributes.Static | FieldAttributes.HasDefault |
FieldAttributes.Literal;
if ((m_fieldAttributes & staticLiteralField) == staticLiteralField)
{
m_value = ParseDefaultValue(declaringType, ppvSigBlob, ppvRawValue);
}
}
public ExtendedQueryParameters()
{
// Default all parameters
QuerySchemas = new string[]{};
MetaQueryValues = new List<MetaQueryItem>();
MetaQueryLogic = QueryLogic.AllCriteriaMatch;
KeywordValues = new List<KeywordItem>();
KeywordQueryLogic = QueryLogic.AllCriteriaMatch;
LastPublishedDate = DateTime.MinValue;
QuerySortField = "ItemTitle";
SortType = MetadataType.STRING;
QuerySortOrder = MetaQueryOrder.Ascending;
MaximumComponents = int.MaxValue;
}
public void AddProperties(StringBuilderWrapper sb, MetadataType type)
{
var makeExtensible = Config.MakeDataContractsExtensible && type.Inherits == null;
var @virtual = Config.MakeVirtual ? "virtual " : "";
var wasAdded = false;
var dataMemberIndex = 1;
if (type.Properties != null)
{
foreach (var prop in type.Properties)
{
if (wasAdded) sb.AppendLine();
var propType = Type(prop.Type, prop.GenericArgs);
wasAdded = AppendDataMember(sb, prop.DataMember, dataMemberIndex++);
wasAdded = AppendAttributes(sb, prop.Attributes) || wasAdded;
sb.AppendLine("public {0}{1} {2} {{ get; set; }}".Fmt(@virtual, propType, prop.Name.SafeToken()));
}
}
if (Config.AddResponseStatus
&& (type.Properties == null
|| type.Properties.All(x => x.Name != "ResponseStatus")))
{
if (wasAdded) sb.AppendLine();
wasAdded = true;
AppendDataMember(sb, null, dataMemberIndex++);
sb.AppendLine("public {0}ResponseStatus ResponseStatus {{ get; set; }}".Fmt(@virtual));
}
if (makeExtensible
&& (type.Properties == null
|| type.Properties.All(x => x.Name != "ExtensionData")))
{
if (wasAdded) sb.AppendLine();
wasAdded = true;
sb.AppendLine("public {0}ExtensionDataObject ExtensionData {{ get; set; }}".Fmt(@virtual));
}
}
private void AddTypeToSortedList(List<MetadataType> allTypes, List<MetadataType> sortedTypes, MetadataType metadataType)
{
if (sortedTypes.Contains(metadataType))
return;
if (metadataType == null)
return;
if (metadataType.Inherits == null)
{
sortedTypes.Add(metadataType);
return;
}
var inheritedMetadataType = FindMetadataTypeByMetadataTypeName(allTypes, metadataType.Inherits);
// Find and add base class first
AddTypeToSortedList(allTypes,sortedTypes, inheritedMetadataType);
if (!sortedTypes.Contains(metadataType))
sortedTypes.Add(metadataType);
}
public MetadataCheckBox(MetadataType metadataType, string displayText, string count)
{
InitializeComponent();
MetadataType = metadataType;
cb.Enabled = PolicyBridge.AllowOverride(metadataType);
cb.Checked = PolicyBridge.IsEnabled(metadataType);
lblMetadataType.Enabled = PolicyBridge.AllowOverride(metadataType);
lblCount.Enabled = PolicyBridge.AllowOverride(metadataType);
if (!lblMetadataType.Enabled)
{
_toolTip = Utils.CreateToolTip(new List<Control>() {this, lblMetadataType, lblCount},
Constants.YourAdminHasLockedThisSetting);
}
lblMetadataType.Text = displayText + ":";
lblCount.Text = count;
lblCount.Click += (sender, args) => Checked = !Checked;
lblMetadataType.Click += (sender, args) => Checked = !Checked;
}
/// <summary>
/// PersistentPutEventArgs Constructor
/// </summary>
/// <param name="parsed">a simple MessageParse</param>
internal PersistentPutEventArgs(dynamic parsed)
{
#if DEBUG
FCP2Protocol.ArgsDebug(this, parsed);
#endif
URI = parsed.URI;
Verbosity = parsed.Verbosity;
PriorityClass = parsed.PriorityClass;
UploadFrom =parsed.UploadFrom;
Filename = parsed.Filename;
TargetFilename = parsed.TargetFilename;
Metadata = new MetadataType(parsed.Metadata);
ClientToken = parsed.ClientToken;
Global = parsed.Global;
DataLength = parsed.DataLength;
MaxRetries = parsed.MaxRetries;
#if DEBUG
parsed.PrintAccessCount();
#endif
}
internal static ContentType ConvertContentType(MetadataType mdt)
{
switch (mdt)
{
case MetadataType.TrackedChange:
return ContentType.TrackChange;
case MetadataType.Author:
return ContentType.Authors;
case MetadataType.Link:
return ContentType.Links;
case MetadataType.Properties:
return ContentType.PDFProperties;
case MetadataType.Attachments:
return ContentType.PDFAttachments;
case MetadataType.Bookmarks:
return ContentType.PDFBookmarks;
case MetadataType.Markups:
return ContentType.PDFMarkups;
default:
return (ContentType)Enum.Parse(typeof(ContentType), mdt.ToString());
}
}
public GCStaticsNode(MetadataType type)
{
Debug.Assert(!type.IsCanonicalSubtype(CanonicalFormKind.Specific));
_type = type;
_preInitFieldInfos = PreInitFieldInfo.GetPreInitFieldInfos(_type);
}
private void AddTypeExtension(ref StringBuilderWrapper sbExt, MetadataType type, bool initCollections)
{
//Swift doesn't support extensions on same protocol used by Base and Sub types
if (type.IsAbstract())
{
return;
}
var typeName = Type(type.Name, type.GenericArgs);
typeName = typeName.LeftPart('<'); // Type<QueryResponse<T>> into correct mapping Type<QueryResponse>
var typeNameOnly = typeName.LeftPart('<');
sbExt.AppendLine();
sbExt.AppendLine("extension {0} : JsonSerializable".Fmt(typeNameOnly));
sbExt.AppendLine("{");
sbExt = sbExt.Indent();
sbExt.AppendLine("public static var typeName:String {{ return \"{0}\" }}".Fmt(typeName));
//func typeConfig()
var isGenericType = type.GenericArgs?.Length > 0 || type.Inherits?.GenericArgs?.Length > 0;
if (!isGenericType)
{
sbExt.AppendLine("public static var metadata = Metadata.create([");
sbExt = sbExt.Indent();
}
else
{
//Swift 2.0 doesn't allow stored static properties on generic types yet
sbExt.AppendLine("public static var metadata:Metadata {");
sbExt = sbExt.Indent();
sbExt.AppendLine("return Metadata.create([");
}
sbExt = sbExt.Indent();
foreach (var prop in GetPropertes(type))
{
var propType = FindType(prop.Type, prop.TypeNamespace, prop.GenericArgs);
if (propType.IsInterface() ||
IgnorePropertyTypeNames.Contains(prop.Type) ||
IgnorePropertyNames.Contains(prop.Name))
{
continue;
}
var fnName = "property";
if (prop.IsArray() || ArrayTypes.Contains(prop.Type))
{
fnName = initCollections
? "arrayProperty"
: "optionalArrayProperty";
}
else if (DictionaryTypes.Contains(prop.Type))
{
fnName = initCollections
? "objectProperty"
: "optionalObjectProperty";
}
else
{
if (propType != null && !propType.IsEnum.GetValueOrDefault())
{
fnName = "optionalObjectProperty";
}
else
{
fnName = "optionalProperty";
}
}
var propName = prop.Name.SafeToken().PropertyStyle();
var unescapedName = propName.UnescapeReserved();
sbExt.AppendLine("Type<{0}>.{1}(\"{2}\", get: {{ $0.{3} }}, set: {{ $0.{3} = $1 }}),".Fmt(
typeName, fnName, unescapedName, propName));
}
sbExt = sbExt.UnIndent();
sbExt.AppendLine("])");
sbExt = sbExt.UnIndent();
if (isGenericType)
{
sbExt.AppendLine("}");
}
sbExt = sbExt.UnIndent();
sbExt.AppendLine("}");
}
internal static extern IntPtr LibVLCMediaGetMeta(IntPtr media, MetadataType metadataType);
public TypeNonGCStaticBaseGenericLookupResult(TypeDesc type)
{
Debug.Assert(type.IsRuntimeDeterminedSubtype, "Concrete static base in a generic dictionary?");
Debug.Assert(type is MetadataType);
_type = (MetadataType)type;
}
public ImportedThreadStaticsOffsetNode(MetadataType type, NodeFactory factory)
: base("__imp_" + ThreadStaticsOffsetNode.GetMangledName(factory.NameMangler, type))
{
}
public static MetadataType GetHelperType(this TypeSystemContext context, string name)
{
MetadataType helperType = context.SystemModule.GetKnownType("Internal.Runtime.CompilerHelpers", name);
return(helperType);
}
public void AddProperties(StringBuilderWrapper sb, MetadataType type,
bool includeResponseStatus,
bool addPropertyAccessors,
string settersReturnType)
{
var wasAdded = false;
var sbInner = StringBuilderCacheAlt.Allocate();
var sbAccessors = new StringBuilderWrapper(sbInner);
if (addPropertyAccessors)
{
sbAccessors.AppendLine();
sbAccessors = sbAccessors.Indent().Indent();
}
var dataMemberIndex = 1;
if (type.Properties != null)
{
foreach (var prop in type.Properties)
{
if (wasAdded) sb.AppendLine();
var propType = Type(prop.Type, prop.GenericArgs);
var fieldName = prop.Name.SafeToken().PropertyStyle();
var accessorName = fieldName.ToPascalCase();
wasAdded = AppendComments(sb, prop.Description);
wasAdded = AppendDataMember(sb, prop.DataMember, dataMemberIndex++) || wasAdded;
wasAdded = AppendAttributes(sb, prop.Attributes) || wasAdded;
if (!fieldName.IsKeyWord())
{
sb.AppendLine("public {0} {1} = null;".Fmt(propType, fieldName));
}
else
{
var originalName = fieldName;
fieldName = Char.ToUpper(fieldName[0]) + fieldName.SafeSubstring(1);
sb.AppendLine("@SerializedName(\"{0}\") public {1} {2} = null;".Fmt(originalName, propType, fieldName));
}
if (addPropertyAccessors)
sbAccessors.AppendPropertyAccessor(propType, fieldName, accessorName, settersReturnType);
}
}
if (includeResponseStatus)
{
if (wasAdded) sb.AppendLine();
AppendDataMember(sb, null, dataMemberIndex++);
sb.AppendLine("public ResponseStatus {0} = null;".Fmt(typeof(ResponseStatus).Name.PropertyStyle()));
if (addPropertyAccessors)
sbAccessors.AppendPropertyAccessor("ResponseStatus", "ResponseStatus", settersReturnType);
}
if (sbAccessors.Length > 0)
sb.AppendLine(StringBuilderCacheAlt.ReturnAndFree(sbInner).TrimEnd()); //remove last \n
}
public bool CanGenerateMetadata(MetadataType type)
{
return((GetMetadataCategory(type) & MetadataCategory.Description) != 0);
}
internal Metadata(string path, MetadataType type, MetadataFormat format)
: this(path, type, format, null, null)
{
}
private void AddEnumExtension(ref StringBuilderWrapper sbExt, MetadataType type)
{
if (type.EnumNames == null)
{
return;
}
sbExt.AppendLine();
var typeName = Type(type.Name, type.GenericArgs);
sbExt.AppendLine("extension {0} : StringSerializable".Fmt(typeName));
sbExt.AppendLine("{");
sbExt = sbExt.Indent();
sbExt.AppendLine("public static var typeName:String {{ return \"{0}\" }}".Fmt(typeName));
//toJson()
sbExt.AppendLine("public func toJson() -> String {");
sbExt = sbExt.Indent();
sbExt.AppendLine("return jsonStringRaw(toString())");
sbExt = sbExt.UnIndent();
sbExt.AppendLine("}");
//toString()
sbExt.AppendLine("public func toString() -> String {");
sbExt = sbExt.Indent();
sbExt.AppendLine("switch self {");
foreach (var name in type.EnumNames)
{
sbExt.AppendLine("case .{0}: return \"{0}\"".Fmt(name));
}
sbExt.AppendLine("}");
sbExt = sbExt.UnIndent();
sbExt.AppendLine("}");
//fromString()
sbExt.AppendLine("public static func fromString(_ strValue:String) -> {0}? {{".Fmt(typeName));
sbExt = sbExt.Indent();
sbExt.AppendLine("switch strValue {");
foreach (var name in type.EnumNames)
{
sbExt.AppendLine("case \"{0}\": return .{0}".Fmt(name));
}
sbExt.AppendLine("default: return nil");
sbExt.AppendLine("}");
sbExt = sbExt.UnIndent();
sbExt.AppendLine("}");
//fromObject()
sbExt.AppendLine("public static func fromObject(_ any:Any) -> {0}? {{".Fmt(typeName));
sbExt = sbExt.Indent();
sbExt.AppendLine("switch any {");
sbExt.AppendLine("case let i as Int: return {0}(rawValue: i)".Fmt(typeName));
sbExt.AppendLine("case let s as String: return fromString(s)");
sbExt.AppendLine("default: return nil");
sbExt.AppendLine("}");
sbExt = sbExt.UnIndent();
sbExt.AppendLine("}");
sbExt = sbExt.UnIndent();
sbExt.AppendLine("}");
}
private void AddEnumExtension(ref StringBuilderWrapper sbExt, MetadataType type)
{
if (type.EnumNames == null) return;
sbExt.AppendLine();
var typeName = Type(type.Name, type.GenericArgs);
sbExt.AppendLine("extension {0} : StringSerializable".Fmt(typeName));
sbExt.AppendLine("{");
sbExt = sbExt.Indent();
sbExt.AppendLine("public static var typeName:String {{ return \"{0}\" }}".Fmt(typeName));
//toJson()
sbExt.AppendLine("public func toJson() -> String {");
sbExt = sbExt.Indent();
sbExt.AppendLine("return jsonStringRaw(toString())");
sbExt = sbExt.UnIndent();
sbExt.AppendLine("}");
//toString()
sbExt.AppendLine("public func toString() -> String {");
sbExt = sbExt.Indent();
sbExt.AppendLine("switch self {");
foreach (var name in type.EnumNames)
{
sbExt.AppendLine("case .{0}: return \"{0}\"".Fmt(name));
}
sbExt.AppendLine("}");
sbExt = sbExt.UnIndent();
sbExt.AppendLine("}");
//fromString()
sbExt.AppendLine("public static func fromString(strValue:String) -> {0}? {{".Fmt(typeName));
sbExt = sbExt.Indent();
sbExt.AppendLine("switch strValue {");
foreach (var name in type.EnumNames)
{
sbExt.AppendLine("case \"{0}\": return .{0}".Fmt(name));
}
sbExt.AppendLine("default: return nil");
sbExt.AppendLine("}");
sbExt = sbExt.UnIndent();
sbExt.AppendLine("}");
//fromObject()
sbExt.AppendLine("public static func fromObject(any:AnyObject) -> {0}? {{".Fmt(typeName));
sbExt = sbExt.Indent();
sbExt.AppendLine("switch any {");
sbExt.AppendLine("case let i as Int: return {0}(rawValue: i)".Fmt(typeName));
sbExt.AppendLine("case let s as String: return fromString(s)");
sbExt.AppendLine("default: return nil");
sbExt.AppendLine("}");
sbExt = sbExt.UnIndent();
sbExt.AppendLine("}");
sbExt = sbExt.UnIndent();
sbExt.AppendLine("}");
}
private void ImportCall(ILOpcode opcode, int token)
{
// Strip runtime determined characteristics off of the method (because that's how RyuJIT operates)
var runtimeDeterminedMethod = (MethodDesc)_methodIL.GetObject(token);
MethodDesc method = runtimeDeterminedMethod;
if (runtimeDeterminedMethod.IsRuntimeDeterminedExactMethod)
{
method = runtimeDeterminedMethod.GetCanonMethodTarget(CanonicalFormKind.Specific);
}
if (method.IsRawPInvoke())
{
// Raw P/invokes don't have any dependencies.
return;
}
string reason = null;
switch (opcode)
{
case ILOpcode.newobj:
reason = "newobj"; break;
case ILOpcode.call:
reason = "call"; break;
case ILOpcode.callvirt:
reason = "callvirt"; break;
case ILOpcode.ldftn:
reason = "ldftn"; break;
case ILOpcode.ldvirtftn:
reason = "ldvirtftn"; break;
default:
Debug.Assert(false); break;
}
if (opcode == ILOpcode.newobj)
{
TypeDesc owningType = runtimeDeterminedMethod.OwningType;
if (owningType.IsString)
{
// String .ctor handled specially below
}
else if (owningType.IsGCPointer)
{
if (owningType.IsRuntimeDeterminedSubtype)
{
_dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.TypeHandle, owningType), reason);
}
else
{
_dependencies.Add(_factory.ConstructedTypeSymbol(owningType), reason);
}
if (owningType.IsMdArray)
{
_dependencies.Add(GetHelperEntrypoint(ReadyToRunHelper.NewMultiDimArr_NonVarArg), reason);
return;
}
else
{
_dependencies.Add(GetHelperEntrypoint(ReadyToRunHelper.NewObject), reason);
}
}
if (owningType.IsDelegate)
{
// If this is a verifiable delegate construction sequence, the previous instruction is a ldftn/ldvirtftn
if (_previousInstructionOffset >= 0 && _ilBytes[_previousInstructionOffset] == (byte)ILOpcode.prefix1)
{
// TODO: for ldvirtftn we need to also check for the `dup` instruction, otherwise this is a normal newobj.
ILOpcode previousOpcode = (ILOpcode)(0x100 + _ilBytes[_previousInstructionOffset + 1]);
if (previousOpcode == ILOpcode.ldvirtftn || previousOpcode == ILOpcode.ldftn)
{
int delTargetToken = ReadILTokenAt(_previousInstructionOffset + 2);
var delTargetMethod = (MethodDesc)_methodIL.GetObject(delTargetToken);
TypeDesc canonDelegateType = method.OwningType.ConvertToCanonForm(CanonicalFormKind.Specific);
DelegateCreationInfo info = _compilation.GetDelegateCtor(canonDelegateType, delTargetMethod, previousOpcode == ILOpcode.ldvirtftn);
if (info.NeedsRuntimeLookup)
{
_dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.DelegateCtor, info), reason);
}
else
{
_dependencies.Add(_factory.ReadyToRunHelper(ReadyToRunHelperId.DelegateCtor, info), reason);
}
return;
}
}
}
}
if (method.OwningType.IsDelegate && method.Name == "Invoke")
{
// TODO: might not want to do this if scanning for reflection.
// This is expanded as an intrinsic, not a function call.
return;
}
if (method.IsIntrinsic)
{
if (IsRuntimeHelpersInitializeArray(method))
{
if (_previousInstructionOffset >= 0 && _ilBytes[_previousInstructionOffset] == (byte)ILOpcode.ldtoken)
{
return;
}
}
if (IsRuntimeTypeHandleGetValueInternal(method))
{
if (_previousInstructionOffset >= 0 && _ilBytes[_previousInstructionOffset] == (byte)ILOpcode.ldtoken)
{
return;
}
}
if (IsActivatorDefaultConstructorOf(method))
{
if (runtimeDeterminedMethod.IsRuntimeDeterminedExactMethod)
{
_dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.DefaultConstructor, runtimeDeterminedMethod.Instantiation[0]), reason);
}
else
{
MethodDesc ctor = method.Instantiation[0].GetDefaultConstructor();
if (ctor == null)
{
MetadataType activatorType = _compilation.TypeSystemContext.SystemModule.GetKnownType("System", "Activator");
MetadataType classWithMissingCtor = activatorType.GetKnownNestedType("ClassWithMissingConstructor");
ctor = classWithMissingCtor.GetParameterlessConstructor();
}
_dependencies.Add(_factory.CanonicalEntrypoint(ctor), reason);
}
return;
}
if (method.OwningType.IsByReferenceOfT && (method.IsConstructor || method.Name == "get_Value"))
{
return;
}
if (IsEETypePtrOf(method))
{
if (runtimeDeterminedMethod.IsRuntimeDeterminedExactMethod)
{
_dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.TypeHandle, runtimeDeterminedMethod.Instantiation[0]), reason);
}
else
{
_dependencies.Add(_factory.ConstructedTypeSymbol(method.Instantiation[0]), reason);
}
return;
}
}
TypeDesc exactType = method.OwningType;
if (method.IsNativeCallable && (opcode != ILOpcode.ldftn && opcode != ILOpcode.ldvirtftn))
{
ThrowHelper.ThrowInvalidProgramException(ExceptionStringID.InvalidProgramNativeCallable, method);
}
bool resolvedConstraint = false;
bool forceUseRuntimeLookup = false;
MethodDesc methodAfterConstraintResolution = method;
if (_constrained != null)
{
// We have a "constrained." call. Try a partial resolve of the constraint call. Note that this
// will not necessarily resolve the call exactly, since we might be compiling
// shared generic code - it may just resolve it to a candidate suitable for
// JIT compilation, and require a runtime lookup for the actual code pointer
// to call.
TypeDesc constrained = _constrained;
if (constrained.IsRuntimeDeterminedSubtype)
{
constrained = constrained.ConvertToCanonForm(CanonicalFormKind.Specific);
}
MethodDesc directMethod = constrained.GetClosestDefType().TryResolveConstraintMethodApprox(method.OwningType, method, out forceUseRuntimeLookup);
if (directMethod == null && constrained.IsEnum)
{
// Constrained calls to methods on enum methods resolve to System.Enum's methods. System.Enum is a reference
// type though, so we would fail to resolve and box. We have a special path for those to avoid boxing.
directMethod = _compilation.TypeSystemContext.TryResolveConstrainedEnumMethod(constrained, method);
}
if (directMethod != null)
{
// Either
// 1. no constraint resolution at compile time (!directMethod)
// OR 2. no code sharing lookup in call
// OR 3. we have have resolved to an instantiating stub
methodAfterConstraintResolution = directMethod;
Debug.Assert(!methodAfterConstraintResolution.OwningType.IsInterface);
resolvedConstraint = true;
exactType = constrained;
}
else if (constrained.IsValueType)
{
// We'll need to box `this`. Note we use _constrained here, because the other one is canonical.
AddBoxingDependencies(_constrained, reason);
}
}
MethodDesc targetMethod = methodAfterConstraintResolution;
bool exactContextNeedsRuntimeLookup;
if (targetMethod.HasInstantiation)
{
exactContextNeedsRuntimeLookup = targetMethod.IsSharedByGenericInstantiations;
}
else
{
exactContextNeedsRuntimeLookup = exactType.IsCanonicalSubtype(CanonicalFormKind.Any);
}
//
// Determine whether to perform direct call
//
bool directCall = false;
if (targetMethod.Signature.IsStatic)
{
// Static methods are always direct calls
directCall = true;
}
else if (targetMethod.OwningType.IsInterface)
{
// Force all interface calls to be interpreted as if they are virtual.
directCall = false;
}
else if ((opcode != ILOpcode.callvirt && opcode != ILOpcode.ldvirtftn) || resolvedConstraint)
{
directCall = true;
}
else
{
if (!targetMethod.IsVirtual || targetMethod.IsFinal || targetMethod.OwningType.IsSealed())
{
directCall = true;
}
}
bool allowInstParam = opcode != ILOpcode.ldvirtftn && opcode != ILOpcode.ldftn;
if (directCall && !allowInstParam && targetMethod.GetCanonMethodTarget(CanonicalFormKind.Specific).RequiresInstArg())
{
// Needs a single address to call this method but the method needs a hidden argument.
// We need a fat function pointer for this that captures both things.
if (exactContextNeedsRuntimeLookup)
{
_dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.MethodEntry, runtimeDeterminedMethod), reason);
}
else
{
_dependencies.Add(_factory.FatFunctionPointer(runtimeDeterminedMethod), reason);
}
}
else if (directCall)
{
bool referencingArrayAddressMethod = false;
if (targetMethod.IsIntrinsic)
{
// If this is an intrinsic method with a callsite-specific expansion, this will replace
// the method with a method the intrinsic expands into. If it's not the special intrinsic,
// method stays unchanged.
targetMethod = _compilation.ExpandIntrinsicForCallsite(targetMethod, _canonMethod);
// Array address method requires special dependency tracking.
referencingArrayAddressMethod = targetMethod.IsArrayAddressMethod();
}
MethodDesc concreteMethod = targetMethod;
targetMethod = targetMethod.GetCanonMethodTarget(CanonicalFormKind.Specific);
if (targetMethod.IsConstructor && targetMethod.OwningType.IsString)
{
_dependencies.Add(_factory.StringAllocator(targetMethod), reason);
}
else if (exactContextNeedsRuntimeLookup)
{
if (targetMethod.IsSharedByGenericInstantiations && !resolvedConstraint && !referencingArrayAddressMethod)
{
ISymbolNode instParam = null;
if (targetMethod.RequiresInstMethodDescArg())
{
instParam = GetGenericLookupHelper(ReadyToRunHelperId.MethodDictionary, runtimeDeterminedMethod);
}
else if (targetMethod.RequiresInstMethodTableArg())
{
bool hasHiddenParameter = true;
if (targetMethod.IsIntrinsic)
{
if (_factory.TypeSystemContext.IsSpecialUnboxingThunkTargetMethod(targetMethod))
{
hasHiddenParameter = false;
}
}
if (hasHiddenParameter)
{
instParam = GetGenericLookupHelper(ReadyToRunHelperId.TypeHandle, runtimeDeterminedMethod.OwningType);
}
}
if (instParam != null)
{
_dependencies.Add(instParam, reason);
}
_dependencies.Add(_factory.RuntimeDeterminedMethod(runtimeDeterminedMethod), reason);
}
else
{
Debug.Assert(!forceUseRuntimeLookup);
_dependencies.Add(_factory.MethodEntrypoint(targetMethod), reason);
if (targetMethod.RequiresInstMethodTableArg() && resolvedConstraint)
{
if (_constrained.IsRuntimeDeterminedSubtype)
{
_dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.TypeHandle, _constrained), reason);
}
else
{
_dependencies.Add(_factory.ConstructedTypeSymbol(_constrained), reason);
}
}
if (referencingArrayAddressMethod && !_isReadOnly)
{
// Address method is special - it expects an instantiation argument, unless a readonly prefix was applied.
_dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.TypeHandle, runtimeDeterminedMethod.OwningType), reason);
}
}
}
else
{
ISymbolNode instParam = null;
if (targetMethod.RequiresInstMethodDescArg())
{
instParam = _compilation.NodeFactory.MethodGenericDictionary(concreteMethod);
}
else if (targetMethod.RequiresInstMethodTableArg() || (referencingArrayAddressMethod && !_isReadOnly))
{
// Ask for a constructed type symbol because we need the vtable to get to the dictionary
instParam = _compilation.NodeFactory.ConstructedTypeSymbol(concreteMethod.OwningType);
}
if (instParam != null)
{
_dependencies.Add(instParam, reason);
if (!referencingArrayAddressMethod)
{
_dependencies.Add(_compilation.NodeFactory.ShadowConcreteMethod(concreteMethod), reason);
}
else
{
// We don't want array Address method to be modeled in the generic dependency analysis.
// The method doesn't actually have runtime determined dependencies (won't do
// any generic lookups).
_dependencies.Add(_compilation.NodeFactory.MethodEntrypoint(targetMethod), reason);
}
}
else if (targetMethod.AcquiresInstMethodTableFromThis())
{
_dependencies.Add(_compilation.NodeFactory.ShadowConcreteMethod(concreteMethod), reason);
}
else
{
_dependencies.Add(_compilation.NodeFactory.MethodEntrypoint(targetMethod), reason);
}
}
}
else if (method.HasInstantiation)
{
// Generic virtual method call
if (exactContextNeedsRuntimeLookup)
{
_dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.MethodHandle, runtimeDeterminedMethod), reason);
}
else
{
_dependencies.Add(_factory.RuntimeMethodHandle(runtimeDeterminedMethod), reason);
}
_dependencies.Add(GetHelperEntrypoint(ReadyToRunHelper.GVMLookupForSlot), reason);
}
else if (method.OwningType.IsInterface)
{
if (exactContextNeedsRuntimeLookup)
{
_dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.VirtualDispatchCell, runtimeDeterminedMethod), reason);
}
else
{
_dependencies.Add(_factory.InterfaceDispatchCell(method), reason);
}
}
else if (_compilation.HasFixedSlotVTable(method.OwningType))
{
// No dependencies: virtual call through the vtable
}
else
{
MethodDesc slotDefiningMethod = targetMethod.IsNewSlot ?
targetMethod : MetadataVirtualMethodAlgorithm.FindSlotDefiningMethodForVirtualMethod(targetMethod);
_dependencies.Add(_factory.VirtualMethodUse(slotDefiningMethod), reason);
}
}
public static bool IsNestedPublic(this MetadataType mdType)
{
return(mdType.GetTypeDefinition() is EcmaType ecmaType &&
(ecmaType.Attributes & TypeAttributes.VisibilityMask) == TypeAttributes.NestedPublic);
}
private string AppendType(ref StringBuilderWrapper sb, ref StringBuilderWrapper sbExt, MetadataType type, string lastNS,
CreateTypeOptions options)
{
//sb = sb.Indent();
var hasGenericBaseType = type.Inherits != null && !type.Inherits.GenericArgs.IsEmpty();
if (Config.ExcludeGenericBaseTypes && hasGenericBaseType)
{
sb.AppendLine("//Excluded {0} : {1}<{2}>".Fmt(type.Name, type.Inherits.Name.LeftPart('`'), string.Join(",", type.Inherits.GenericArgs)));
return(lastNS);
}
sb.AppendLine();
AppendComments(sb, type.Description);
if (type.Routes != null)
{
AppendAttributes(sb, type.Routes.ConvertAll(x => x.ToMetadataAttribute()));
}
AppendAttributes(sb, type.Attributes);
AppendDataContract(sb, type.DataContract);
if (type.IsEnum.GetValueOrDefault())
{
sb.AppendLine("public enum {0} : Int".Fmt(Type(type.Name, type.GenericArgs)));
sb.AppendLine("{");
sb = sb.Indent();
if (type.EnumNames != null)
{
for (var i = 0; i < type.EnumNames.Count; i++)
{
var name = type.EnumNames[i];
var value = type.EnumValues != null ? type.EnumValues[i] : null;
sb.AppendLine(value == null
? "case {0}".Fmt(name)
: "case {0} = {1}".Fmt(name, value));
}
}
sb = sb.UnIndent();
sb.AppendLine("}");
AddEnumExtension(ref sbExt, type);
}
else
{
var defType = "class";
var typeName = Type(type.Name, type.GenericArgs).AddGenericConstraints();
var extends = new List <string>();
//: BaseClass, Interfaces
if (type.Inherits != null)
{
var baseType = Type(type.Inherits).InheritedType();
//Swift requires re-declaring base type generics definition on super type
var genericDefPos = baseType.IndexOf("<");
if (genericDefPos >= 0)
{
//Need to declare BaseType is JsonSerializable
var subBaseType = baseType.Substring(genericDefPos)
.AddGenericConstraints();
typeName += subBaseType;
}
extends.Add(baseType);
}
else if (Config.BaseClass != null && !type.IsInterface())
{
extends.Add(Config.BaseClass);
}
var typeAliases = new List <string>();
if (options.ImplementsFn != null)
{
//Swift doesn't support Generic Interfaces like IReturn<T>
//Converting them into protocols with typealiases instead
ExtractTypeAliases(options, typeAliases, extends, ref sbExt);
if (!type.Implements.IsEmpty())
{
type.Implements.Each(x => extends.Add(Type(x)));
}
}
if (type.IsInterface())
{
defType = "protocol";
//Extract Protocol Arguments into different typealiases
if (!type.GenericArgs.IsEmpty())
{
typeName = Type(type.Name, null);
foreach (var arg in type.GenericArgs)
{
typeAliases.Add($"associatedtype {arg}");
}
}
}
var extend = extends.Count > 0
? " : " + (string.Join(", ", extends.ToArray()))
: "";
sb.AppendLine($"public {defType} {typeName}{extend}");
sb.AppendLine("{");
sb = sb.Indent();
if (typeAliases.Count > 0)
{
foreach (var typeAlias in typeAliases)
{
sb.AppendLine(typeAlias);
}
sb.AppendLine();
}
if (!type.IsInterface())
{
if (extends.Count > 0 && OverrideInitForBaseClasses.Contains(extends[0]))
{
sb.AppendLine("required public override init(){}");
}
else
{
sb.AppendLine("required public init(){}");
}
}
var addVersionInfo = Config.AddImplicitVersion != null && options.IsRequest;
if (addVersionInfo)
{
sb.AppendLine($"public var {"Version".PropertyStyle()}:Int = {Config.AddImplicitVersion}");
}
var initCollections = feature.ShouldInitializeCollections(type, Config.InitializeCollections);
AddProperties(sb, type,
initCollections: !type.IsInterface() && initCollections,
includeResponseStatus: Config.AddResponseStatus && options.IsResponse &&
type.Properties.Safe().All(x => x.Name != typeof(ResponseStatus).Name));
sb = sb.UnIndent();
sb.AppendLine("}");
if (!type.IsInterface())
{
AddTypeExtension(ref sbExt, type,
initCollections: Config.InitializeCollections);
}
}
//sb = sb.UnIndent();
return(lastNS);
}
internal static extern bool StreamDecoderSetMetadataRespond(
StreamDecoderHandle handle,
MetadataType metadataType);
/// <summary>
/// Provides method bodies for intrinsics recognized by the compiler.
/// It can return null if it's not an intrinsic recognized by the compiler,
/// but an intrinsic e.g. recognized by codegen.
/// </summary>
private MethodIL TryGetIntrinsicMethodIL(MethodDesc method)
{
Debug.Assert(method.IsIntrinsic);
MetadataType owningType = method.OwningType as MetadataType;
if (owningType == null)
{
return(null);
}
switch (owningType.Name)
{
case "Interlocked":
{
if (owningType.Namespace == "System.Threading")
{
return(InterlockedIntrinsics.EmitIL(method));
}
}
break;
case "Unsafe":
{
if (owningType.Namespace == "Internal.Runtime.CompilerServices")
{
return(UnsafeIntrinsics.EmitIL(method));
}
}
break;
case "Volatile":
{
if (owningType.Namespace == "System.Threading")
{
return(VolatileIntrinsics.EmitIL(method));
}
}
break;
case "Debug":
{
if (owningType.Namespace == "System.Diagnostics" && method.Name == "DebugBreak")
{
return(new ILStubMethodIL(method, new byte[] { (byte)ILOpcode.break_, (byte)ILOpcode.ret }, Array.Empty <LocalVariableDefinition>(), null));
}
}
break;
case "EETypePtr":
{
if (owningType.Namespace == "System" && method.Name == "EETypePtrOf")
{
return(EETypePtrOfIntrinsic.EmitIL(method));
}
}
break;
case "RuntimeAugments":
{
if (owningType.Namespace == "Internal.Runtime.Augments" && method.Name == "GetCanonType")
{
return(GetCanonTypeIntrinsic.EmitIL(method));
}
}
break;
case "EEType":
{
if (owningType.Namespace == "Internal.Runtime" && method.Name == "get_SupportsRelativePointers")
{
ILOpcode value = method.Context.Target.SupportsRelativePointers ?
ILOpcode.ldc_i4_1 : ILOpcode.ldc_i4_0;
return(new ILStubMethodIL(method, new byte[] { (byte)value, (byte)ILOpcode.ret }, Array.Empty <LocalVariableDefinition>(), null));
}
}
break;
}
return(null);
}
/// <summary>
/// Provides method bodies for intrinsics recognized by the compiler that
/// are specialized per instantiation. It can return null if the intrinsic
/// is not recognized.
/// </summary>
private MethodIL TryGetPerInstantiationIntrinsicMethodIL(MethodDesc method)
{
Debug.Assert(method.IsIntrinsic);
MetadataType owningType = method.OwningType.GetTypeDefinition() as MetadataType;
if (owningType == null)
{
return(null);
}
string methodName = method.Name;
switch (owningType.Name)
{
case "RuntimeHelpers":
{
if (owningType.Namespace == "System.Runtime.CompilerServices")
{
return(RuntimeHelpersIntrinsics.EmitIL(method));
}
}
break;
case "Comparer`1":
{
if (methodName == "Create" && owningType.Namespace == "System.Collections.Generic")
{
return(ComparerIntrinsics.EmitComparerCreate(method));
}
}
break;
case "EqualityComparer`1":
{
if (methodName == "Create" && owningType.Namespace == "System.Collections.Generic")
{
return(ComparerIntrinsics.EmitEqualityComparerCreate(method));
}
}
break;
case "EqualityComparerHelpers":
{
if (owningType.Namespace != "Internal.IntrinsicSupport")
{
return(null);
}
if (methodName == "EnumOnlyEquals")
{
// EnumOnlyEquals would basically like to do this:
// static bool EnumOnlyEquals<T>(T x, T y) where T: struct => x == y;
// This is not legal though.
// We don't want to do this:
// static bool EnumOnlyEquals<T>(T x, T y) where T: struct => x.Equals(y);
// Because it would box y.
// So we resort to some per-instantiation magic.
TypeDesc elementType = method.Instantiation[0];
if (!elementType.IsEnum)
{
return(null);
}
ILOpcode convInstruction;
if (((DefType)elementType).InstanceFieldSize.AsInt <= 4)
{
convInstruction = ILOpcode.conv_i4;
}
else
{
Debug.Assert(((DefType)elementType).InstanceFieldSize.AsInt == 8);
convInstruction = ILOpcode.conv_i8;
}
return(new ILStubMethodIL(method, new byte[] {
(byte)ILOpcode.ldarg_0,
(byte)convInstruction,
(byte)ILOpcode.ldarg_1,
(byte)convInstruction,
(byte)ILOpcode.prefix1, unchecked ((byte)ILOpcode.ceq),
(byte)ILOpcode.ret,
},
Array.Empty <LocalVariableDefinition>(), null));
}
else if (methodName == "GetComparerForReferenceTypesOnly")
{
TypeDesc elementType = method.Instantiation[0];
if (!elementType.IsRuntimeDeterminedSubtype &&
!elementType.IsCanonicalSubtype(CanonicalFormKind.Any) &&
!elementType.IsGCPointer)
{
return(new ILStubMethodIL(method, new byte[] {
(byte)ILOpcode.ldnull,
(byte)ILOpcode.ret
},
Array.Empty <LocalVariableDefinition>(), null));
}
}
else if (methodName == "StructOnlyEquals")
{
TypeDesc elementType = method.Instantiation[0];
if (!elementType.IsRuntimeDeterminedSubtype &&
!elementType.IsCanonicalSubtype(CanonicalFormKind.Any) &&
!elementType.IsGCPointer)
{
Debug.Assert(elementType.IsValueType);
TypeSystemContext context = elementType.Context;
MetadataType helperType = context.SystemModule.GetKnownType("Internal.IntrinsicSupport", "EqualityComparerHelpers");
MethodDesc methodToCall;
if (elementType.IsEnum)
{
methodToCall = helperType.GetKnownMethod("EnumOnlyEquals", null).MakeInstantiatedMethod(elementType);
}
else if (elementType.IsNullable && ComparerIntrinsics.ImplementsIEquatable(elementType.Instantiation[0]))
{
methodToCall = helperType.GetKnownMethod("StructOnlyEqualsNullable", null).MakeInstantiatedMethod(elementType.Instantiation[0]);
}
else if (ComparerIntrinsics.ImplementsIEquatable(elementType))
{
methodToCall = helperType.GetKnownMethod("StructOnlyEqualsIEquatable", null).MakeInstantiatedMethod(elementType);
}
else
{
methodToCall = helperType.GetKnownMethod("StructOnlyNormalEquals", null).MakeInstantiatedMethod(elementType);
}
return(new ILStubMethodIL(method, new byte[]
{
(byte)ILOpcode.ldarg_0,
(byte)ILOpcode.ldarg_1,
(byte)ILOpcode.call, 1, 0, 0, 0,
(byte)ILOpcode.ret
},
Array.Empty <LocalVariableDefinition>(), new object[] { methodToCall }));
}
}
}
break;
}
return(null);
}
public MethodIL EmitIL()
{
MethodSignature targetMethodSignature = _targetMethod.Signature;
// We have 4 code streams:
// - _marshallingCodeStream is used to convert each argument into a native type and
// store that into the local
// - callsiteSetupCodeStream is used to used to load each previously generated local
// and call the actual target native method.
// - _returnValueMarshallingCodeStream is used to convert the native return value
// to managed one.
// - _unmarshallingCodestream is used to propagate [out] native arguments values to
// managed ones.
_emitter = new ILEmitter();
ILCodeStream fnptrLoadStream = _emitter.NewCodeStream();
_marshallingCodeStream = _emitter.NewCodeStream();
ILCodeStream callsiteSetupCodeStream = _emitter.NewCodeStream();
_returnValueMarshallingCodeStream = _emitter.NewCodeStream();
_unmarshallingCodestream = _emitter.NewCodeStream();
TypeDesc[] nativeParameterTypes = new TypeDesc[targetMethodSignature.Length];
//
// Parameter marshalling
//
//
// Convert each argument to something we can pass to native and store it in a local.
// Then load the local in the second code stream.
//
for (int i = 0; i < targetMethodSignature.Length; i++)
{
// TODO: throw if there's custom marshalling
_marshallingCodeStream.EmitLdArg(i);
TypeDesc nativeType = MarshalArgument(targetMethodSignature[i]);
nativeParameterTypes[i] = nativeType;
ILLocalVariable vMarshalledTypeTemp = _emitter.NewLocal(nativeType);
_marshallingCodeStream.EmitStLoc(vMarshalledTypeTemp);
callsiteSetupCodeStream.EmitLdLoc(vMarshalledTypeTemp);
}
//
// Return value marshalling
//
// TODO: throw if SetLastError is true
// TODO: throw if there's custom marshalling
TypeDesc nativeReturnType = MarshalReturnValue(targetMethodSignature.ReturnType);
if (UseLazyResolution(_targetMethod, _importMetadata.Module))
{
MetadataType lazyHelperType = _targetMethod.Context.GetHelperType("InteropHelpers");
FieldDesc lazyDispatchCell = new PInvokeLazyFixupField((DefType)_targetMethod.OwningType, _importMetadata);
fnptrLoadStream.Emit(ILOpcode.ldsflda, _emitter.NewToken(lazyDispatchCell));
fnptrLoadStream.Emit(ILOpcode.call, _emitter.NewToken(lazyHelperType.GetKnownMethod("ResolvePInvoke", null)));
MethodSignatureFlags unmanagedCallConv = PInvokeMetadata.GetUnmanagedCallingConvention(_importMetadata.Attributes);
MethodSignature nativeCalliSig = new MethodSignature(
targetMethodSignature.Flags | unmanagedCallConv, 0, nativeReturnType, nativeParameterTypes);
ILLocalVariable vNativeFunctionPointer = _emitter.NewLocal(_targetMethod.Context.GetWellKnownType(WellKnownType.IntPtr));
fnptrLoadStream.EmitStLoc(vNativeFunctionPointer);
callsiteSetupCodeStream.EmitLdLoc(vNativeFunctionPointer);
callsiteSetupCodeStream.Emit(ILOpcode.calli, _emitter.NewToken(nativeCalliSig));
}
else
{
// Eager call
PInvokeMetadata nativeImportMetadata =
new PInvokeMetadata(_importMetadata.Module, _importMetadata.Name ?? _targetMethod.Name, _importMetadata.Attributes);
MethodSignature nativeSig = new MethodSignature(
targetMethodSignature.Flags, 0, nativeReturnType, nativeParameterTypes);
MethodDesc nativeMethod =
new PInvokeTargetNativeMethod(_targetMethod.OwningType, nativeSig, nativeImportMetadata);
callsiteSetupCodeStream.Emit(ILOpcode.call, _emitter.NewToken(nativeMethod));
}
_unmarshallingCodestream.Emit(ILOpcode.ret);
return(_emitter.Link(_targetMethod));
}
internal static extern void LibVLCMediaSetMeta(IntPtr media, MetadataType metadataType, [MarshalAs(UnmanagedType.LPStr)] string value);
internal static extern MetadataBlockHandle MetadataObjectNew(
MetadataType blockType);
public bool GeneratesMetadata(MetadataType typeDef)
{
return(_typeGeneratesMetadata(typeDef));
}
public string GetCode(MetadataTypes metadata, IRequest request, INativeTypesMetadata nativeTypes)
{
var typeNamespaces = new HashSet <string>();
RemoveIgnoredTypes(metadata);
metadata.Types.Each(x => typeNamespaces.Add(x.Namespace));
metadata.Operations.Each(x => typeNamespaces.Add(x.Request.Namespace));
var defaultImports = new List <string>(DefaultImports);
if (!Config.DefaultImports.IsEmpty())
{
defaultImports = Config.DefaultImports;
}
else if (ReferencesGson(metadata))
{
if (!defaultImports.Contains(GSonAnnotationsNamespace))
{
defaultImports.Add(GSonAnnotationsNamespace);
}
if (!defaultImports.Contains(GSonReflectNamespace))
{
defaultImports.Add(GSonReflectNamespace);
}
}
var defaultNamespace = Config.GlobalNamespace ?? DefaultGlobalNamespace;
Func <string, string> defaultValue = k =>
request.QueryString[k].IsNullOrEmpty() ? "//" : "";
var sbInner = StringBuilderCache.Allocate();
var sb = new StringBuilderWrapper(sbInner);
sb.AppendLine("/* Options:");
sb.AppendLine("Date: {0}".Fmt(DateTime.Now.ToString("s").Replace("T", " ")));
sb.AppendLine("Version: {0}".Fmt(Env.ServiceStackVersion));
sb.AppendLine("Tip: {0}".Fmt(HelpMessages.NativeTypesDtoOptionsTip.Fmt("//")));
sb.AppendLine("BaseUrl: {0}".Fmt(Config.BaseUrl));
sb.AppendLine();
sb.AppendLine("{0}Package: {1}".Fmt(defaultValue("Package"), Config.Package));
sb.AppendLine("{0}GlobalNamespace: {1}".Fmt(defaultValue("GlobalNamespace"), defaultNamespace));
sb.AppendLine("{0}AddPropertyAccessors: {1}".Fmt(defaultValue("AddPropertyAccessors"), Config.AddPropertyAccessors));
sb.AppendLine("{0}SettersReturnThis: {1}".Fmt(defaultValue("SettersReturnThis"), Config.SettersReturnThis));
sb.AppendLine("{0}AddServiceStackTypes: {1}".Fmt(defaultValue("AddServiceStackTypes"), Config.AddServiceStackTypes));
sb.AppendLine("{0}AddResponseStatus: {1}".Fmt(defaultValue("AddResponseStatus"), Config.AddResponseStatus));
sb.AppendLine("{0}AddDescriptionAsComments: {1}".Fmt(defaultValue("AddDescriptionAsComments"), Config.AddDescriptionAsComments));
sb.AppendLine("{0}AddImplicitVersion: {1}".Fmt(defaultValue("AddImplicitVersion"), Config.AddImplicitVersion));
sb.AppendLine("{0}IncludeTypes: {1}".Fmt(defaultValue("IncludeTypes"), Config.IncludeTypes.Safe().ToArray().Join(",")));
sb.AppendLine("{0}ExcludeTypes: {1}".Fmt(defaultValue("ExcludeTypes"), Config.ExcludeTypes.Safe().ToArray().Join(",")));
sb.AppendLine("{0}TreatTypesAsStrings: {1}".Fmt(defaultValue("TreatTypesAsStrings"), Config.TreatTypesAsStrings.Safe().ToArray().Join(",")));
sb.AppendLine("{0}DefaultImports: {1}".Fmt(defaultValue("DefaultImports"), defaultImports.Join(",")));
sb.AppendLine("*/");
sb.AppendLine();
foreach (var typeName in Config.TreatTypesAsStrings.Safe())
{
TypeAliases[typeName] = "String";
}
if (Config.Package != null)
{
sb.AppendLine("package {0};".Fmt(Config.Package));
sb.AppendLine();
}
string lastNS = null;
var existingTypes = new HashSet <string>();
var requestTypes = metadata.Operations.Select(x => x.Request).ToHashSet();
var requestTypesMap = metadata.Operations.ToSafeDictionary(x => x.Request);
var responseTypes = metadata.Operations
.Where(x => x.Response != null)
.Select(x => x.Response).ToHashSet();
var types = metadata.Types.ToHashSet();
AllTypes.AddRange(requestTypes);
AllTypes.AddRange(responseTypes);
AllTypes.AddRange(types);
AllTypes = FilterTypes(AllTypes);
//TypeScript doesn't support reusing same type name with different generic airity
var conflictPartialNames = AllTypes.Map(x => x.Name).Distinct()
.GroupBy(g => g.LeftPart('`'))
.Where(g => g.Count() > 1)
.Select(g => g.Key)
.ToList();
this.conflictTypeNames = AllTypes
.Where(x => conflictPartialNames.Any(name => x.Name.StartsWith(name)))
.Map(x => x.Name);
defaultImports.Each(x => sb.AppendLine("import {0};".Fmt(x)));
sb.AppendLine();
sb.AppendLine("public class {0}".Fmt(defaultNamespace.SafeToken()));
sb.AppendLine("{");
//ServiceStack core interfaces
foreach (var type in AllTypes)
{
var fullTypeName = type.GetFullName();
if (requestTypes.Contains(type))
{
if (!existingTypes.Contains(fullTypeName))
{
MetadataType response = null;
MetadataOperationType operation;
if (requestTypesMap.TryGetValue(type, out operation))
{
response = operation.Response;
}
lastNS = AppendType(ref sb, type, lastNS,
new CreateTypeOptions
{
ImplementsFn = () =>
{
if (!Config.AddReturnMarker &&
!type.ReturnVoidMarker &&
type.ReturnMarkerTypeName == null)
{
return(null);
}
if (type.ReturnVoidMarker)
{
return("IReturnVoid");
}
if (type.ReturnMarkerTypeName != null)
{
return(Type("IReturn`1", new[] { Type(type.ReturnMarkerTypeName) }));
}
return(response != null
? Type("IReturn`1", new[] { Type(response.Name, response.GenericArgs) })
: null);
},
IsRequest = true,
});
existingTypes.Add(fullTypeName);
}
}
else if (responseTypes.Contains(type))
{
if (!existingTypes.Contains(fullTypeName) &&
!Config.IgnoreTypesInNamespaces.Contains(type.Namespace))
{
lastNS = AppendType(ref sb, type, lastNS,
new CreateTypeOptions
{
IsResponse = true,
});
existingTypes.Add(fullTypeName);
}
}
else if (types.Contains(type) && !existingTypes.Contains(fullTypeName))
{
lastNS = AppendType(ref sb, type, lastNS,
new CreateTypeOptions {
IsType = true
});
existingTypes.Add(fullTypeName);
}
}
sb.AppendLine();
sb.AppendLine("}");
return(StringBuilderCache.ReturnAndFree(sbInner));
}
/// <summary>
/// Generates IL for the IsSupported property that reads this information from a field initialized by the runtime
/// at startup. Returns null for hardware intrinsics whose support level is known at compile time
/// (i.e. they're known to be always supported or always unsupported).
/// </summary>
public static MethodIL EmitIsSupportedIL(MethodDesc method, FieldDesc isSupportedField)
{
Debug.Assert(IsIsSupportedMethod(method));
Debug.Assert(isSupportedField.IsStatic && isSupportedField.FieldType.IsWellKnownType(WellKnownType.Int32));
TargetDetails target = method.Context.Target;
MetadataType owningType = (MetadataType)method.OwningType;
// Check for case of nested "X64" types
if (owningType.Name == "X64")
{
if (target.Architecture != TargetArchitecture.X64)
{
return(null);
}
// Un-nest the type so that we can do a name match
owningType = (MetadataType)owningType.ContainingType;
}
int flag;
if ((target.Architecture == TargetArchitecture.X64 || target.Architecture == TargetArchitecture.X86) &&
owningType.Namespace == "System.Runtime.Intrinsics.X86")
{
switch (owningType.Name)
{
case "Aes":
flag = XArchIntrinsicConstants.Aes;
break;
case "Pclmulqdq":
flag = XArchIntrinsicConstants.Pclmulqdq;
break;
case "Sse3":
flag = XArchIntrinsicConstants.Sse3;
break;
case "Ssse3":
flag = XArchIntrinsicConstants.Ssse3;
break;
case "Lzcnt":
flag = XArchIntrinsicConstants.Lzcnt;
break;
// NOTE: this switch is complemented by IsKnownSupportedIntrinsicAtCompileTime
// in the method below.
default:
return(null);
}
}
else
{
return(null);
}
var emit = new ILEmitter();
ILCodeStream codeStream = emit.NewCodeStream();
codeStream.Emit(ILOpcode.ldsfld, emit.NewToken(isSupportedField));
codeStream.EmitLdc(flag);
codeStream.Emit(ILOpcode.and);
codeStream.EmitLdc(0);
codeStream.Emit(ILOpcode.cgt_un);
codeStream.Emit(ILOpcode.ret);
return(emit.Link(method));
}
public ArrayIndexExpression(Expression array, Expression index, MetadataType type, TypeReference objectType)
: this(array, index, type, objectType, instruction : null)
{
}
public InlineArrayCandidate(MetadataType type, uint length)
{
ElementType = type;
Length = length;
}
private string AppendType(ref StringBuilderWrapper sb, MetadataType type, string lastNS,
CreateTypeOptions options)
{
sb = sb.Indent();
sb.AppendLine();
AppendComments(sb, type.Description);
if (type.Routes != null)
{
AppendAttributes(sb, type.Routes.ConvertAll(x => x.ToMetadataAttribute()));
}
AppendAttributes(sb, type.Attributes);
AppendDataContract(sb, type.DataContract);
var typeName = Type(type.Name, type.GenericArgs);
if (type.IsEnum.GetValueOrDefault())
{
sb.AppendLine("public static enum {0}".Fmt(typeName));
sb.AppendLine("{");
sb = sb.Indent();
if (type.EnumNames != null)
{
var hasIntValue = false;
for (var i = 0; i < type.EnumNames.Count; i++)
{
var name = type.EnumNames[i];
var value = type.EnumValues != null ? type.EnumValues[i] : null;
var delim = i == type.EnumNames.Count - 1 ? ";" : ",";
var serializeAs = JsConfig.TreatEnumAsInteger || (type.Attributes.Safe().Any(x => x.Name == "Flags"))
? "@SerializedName(\"{0}\") ".Fmt(value)
: "";
sb.AppendLine(value == null
? "{0}{1}".Fmt(name.ToPascalCase(), delim)
: serializeAs + "{0}({1}){2}".Fmt(name.ToPascalCase(), value, delim));
hasIntValue = hasIntValue || value != null;
}
if (hasIntValue)
{
sb.AppendLine();
sb.AppendLine("private final int value;");
sb.AppendLine("{0}(final int intValue) {{ value = intValue; }}".Fmt(typeName));
sb.AppendLine("public int getValue() { return value; }");
}
}
sb = sb.UnIndent();
sb.AppendLine("}");
}
else
{
var defType = type.IsInterface()
? "interface"
: "class";
var extends = new List <string>();
//: BaseClass, Interfaces
if (type.Inherits != null)
{
extends.Add(Type(type.Inherits).InheritedType());
}
string responseTypeExpression = null;
var interfaces = new List <string>();
if (options.ImplementsFn != null)
{
var implStr = options.ImplementsFn();
if (!string.IsNullOrEmpty(implStr))
{
interfaces.Add(implStr);
if (implStr.StartsWith("IReturn<"))
{
var types = implStr.RightPart('<');
var returnType = types.Substring(0, types.Length - 1);
//Can't get .class from Generic Type definition
responseTypeExpression = returnType.Contains("<")
? "new TypeToken<{0}>(){{}}.getType()".Fmt(returnType)
: "{0}.class".Fmt(returnType);
}
}
if (!type.Implements.IsEmpty())
{
foreach (var interfaceRef in type.Implements)
{
interfaces.Add(Type(interfaceRef));
}
}
}
var extend = extends.Count > 0
? " extends " + extends[0]
: "";
if (interfaces.Count > 0)
{
extend += " implements " + string.Join(", ", interfaces.ToArray());
}
var addPropertyAccessors = Config.AddPropertyAccessors && !type.IsInterface();
var settersReturnType = addPropertyAccessors && Config.SettersReturnThis ? typeName : null;
sb.AppendLine("public static {0} {1}{2}".Fmt(defType, typeName, extend));
sb.AppendLine("{");
sb = sb.Indent();
var addVersionInfo = Config.AddImplicitVersion != null && options.IsRequest;
if (addVersionInfo)
{
sb.AppendLine("public Integer {0} = {1};".Fmt("Version".PropertyStyle(), Config.AddImplicitVersion));
if (addPropertyAccessors)
{
sb.AppendPropertyAccessor("Integer", "Version", settersReturnType);
}
}
AddProperties(sb, type,
includeResponseStatus: Config.AddResponseStatus && options.IsResponse &&
type.Properties.Safe().All(x => x.Name != typeof(ResponseStatus).Name),
addPropertyAccessors: addPropertyAccessors,
settersReturnType: settersReturnType);
if (responseTypeExpression != null)
{
sb.AppendLine("private static Object responseType = {0};".Fmt(responseTypeExpression));
sb.AppendLine("public Object getResponseType() { return responseType; }");
}
sb = sb.UnIndent();
sb.AppendLine("}");
}
sb = sb.UnIndent();
return(lastNS);
}
public void AddProperties(StringBuilderWrapper sb, MetadataType type,
bool includeResponseStatus,
bool addPropertyAccessors,
string settersReturnType)
{
var wasAdded = false;
var sbInner = StringBuilderCacheAlt.Allocate();
var sbAccessors = new StringBuilderWrapper(sbInner);
if (addPropertyAccessors)
{
sbAccessors.AppendLine();
sbAccessors = sbAccessors.Indent().Indent();
}
var dataMemberIndex = 1;
if (type.Properties != null)
{
foreach (var prop in type.Properties)
{
if (wasAdded)
{
sb.AppendLine();
}
var propType = Type(prop.Type, prop.GenericArgs);
var fieldName = prop.Name.SafeToken().PropertyStyle();
var accessorName = fieldName.ToPascalCase();
wasAdded = AppendComments(sb, prop.Description);
wasAdded = AppendDataMember(sb, prop.DataMember, dataMemberIndex++) || wasAdded;
wasAdded = AppendAttributes(sb, prop.Attributes) || wasAdded;
if (!fieldName.IsKeyWord())
{
sb.AppendLine("public {0} {1} = null;".Fmt(propType, fieldName));
}
else
{
var originalName = fieldName;
fieldName = Char.ToUpper(fieldName[0]) + fieldName.SafeSubstring(1);
sb.AppendLine("@SerializedName(\"{0}\") public {1} {2} = null;".Fmt(originalName, propType, fieldName));
}
if (addPropertyAccessors)
{
sbAccessors.AppendPropertyAccessor(propType, fieldName, accessorName, settersReturnType);
}
}
}
if (includeResponseStatus)
{
if (wasAdded)
{
sb.AppendLine();
}
AppendDataMember(sb, null, dataMemberIndex++);
sb.AppendLine("public ResponseStatus {0} = null;".Fmt(typeof(ResponseStatus).Name.PropertyStyle()));
if (addPropertyAccessors)
{
sbAccessors.AppendPropertyAccessor("ResponseStatus", "ResponseStatus", settersReturnType);
}
}
if (sbAccessors.Length > 0)
{
sb.AppendLine(StringBuilderCacheAlt.ReturnAndFree(sbInner).TrimEnd()); //remove last \n
}
}
public TypeDesc GetSystemType()
{
MetadataType systemType = _module.Context.SystemModule.GetType("System", "Type");
return(systemType);
}
public void AddProperties(StringBuilderWrapper sb, MetadataType type,
bool initCollections, bool includeResponseStatus)
{
var wasAdded = false;
var dataMemberIndex = 1;
foreach (var prop in type.Properties.Safe())
{
if (wasAdded)
{
sb.AppendLine();
}
var propTypeName = Type(prop.Type, prop.GenericArgs);
var propType = FindType(prop.Type, prop.TypeNamespace, prop.GenericArgs);
var optional = "";
var defaultValue = "";
if (propTypeName.EndsWith("?"))
{
propTypeName = propTypeName.Substring(0, propTypeName.Length - 1);
optional = "?";
}
if (Config.MakePropertiesOptional)
{
optional = "?";
}
if (prop.Attributes.Safe().FirstOrDefault(x => x.Name == "Required") != null)
{
optional = "?"; //always use optional
}
if (prop.IsArray())
{
optional = "";
defaultValue = " = []";
}
else if (initCollections && !prop.GenericArgs.IsEmpty())
{
if (ArrayTypes.Contains(prop.Type))
{
optional = "";
defaultValue = " = []";
}
if (DictionaryTypes.Contains(prop.Type))
{
optional = "";
defaultValue = " = [:]";
}
}
if (propType.IsInterface() || IgnorePropertyNames.Contains(prop.Name))
{
sb.AppendLine("//{0}:{1} ignored. Swift doesn't support interface properties"
.Fmt(prop.Name.SafeToken().PropertyStyle(), propTypeName));
continue;
}
else if (IgnorePropertyTypeNames.Contains(propTypeName))
{
sb.AppendLine("//{0}:{1} ignored. Type could not be extended in Swift"
.Fmt(prop.Name.SafeToken().PropertyStyle(), propTypeName));
continue;
}
wasAdded = AppendComments(sb, prop.Description);
wasAdded = AppendDataMember(sb, prop.DataMember, dataMemberIndex++) || wasAdded;
wasAdded = AppendAttributes(sb, prop.Attributes) || wasAdded;
if (type.IsInterface())
{
sb.AppendLine("var {0}:{1}{2} {{ get set }}".Fmt(
prop.Name.SafeToken().PropertyStyle(), propTypeName, optional));
}
else
{
sb.AppendLine("public var {0}:{1}{2}{3}".Fmt(
prop.Name.SafeToken().PropertyStyle(), propTypeName, optional, defaultValue));
}
}
if (includeResponseStatus)
{
if (wasAdded)
{
sb.AppendLine();
}
AppendDataMember(sb, null, dataMemberIndex++);
sb.AppendLine("public var {0}:ResponseStatus?".Fmt(typeof(ResponseStatus).Name.PropertyStyle()));
}
}
public void AddProperties(StringBuilderWrapper sb, MetadataType type,
bool initCollections, bool includeResponseStatus)
{
var wasAdded = false;
var dataMemberIndex = 1;
foreach (var prop in type.Properties.Safe())
{
if (wasAdded) sb.AppendLine();
var propTypeName = Type(prop.Type, prop.GenericArgs);
var propType = FindType(prop.Type, prop.TypeNamespace, prop.GenericArgs);
var optional = "";
var defaultValue = "";
if (propTypeName.EndsWith("?"))
{
propTypeName = propTypeName.Substring(0, propTypeName.Length - 1);
optional = "?";
}
if (Config.MakePropertiesOptional)
{
optional = "?";
}
if (prop.Attributes.Safe().FirstOrDefault(x => x.Name == "Required") != null)
{
optional = "?"; //always use optional
}
if (prop.IsArray())
{
optional = "";
defaultValue = " = []";
}
else if (initCollections && !prop.GenericArgs.IsEmpty())
{
if (ArrayTypes.Contains(prop.Type))
{
optional = "";
defaultValue = " = []";
}
if (DictionaryTypes.Contains(prop.Type))
{
optional = "";
defaultValue = " = [:]";
}
}
if (propType.IsInterface() || IgnorePropertyNames.Contains(prop.Name))
{
sb.AppendLine("//{0}:{1} ignored. Swift doesn't support interface properties"
.Fmt(prop.Name.SafeToken().PropertyStyle(), propTypeName));
continue;
}
else if (IgnorePropertyTypeNames.Contains(propTypeName))
{
sb.AppendLine("//{0}:{1} ignored. Type could not be extended in Swift"
.Fmt(prop.Name.SafeToken().PropertyStyle(), propTypeName));
continue;
}
wasAdded = AppendDataMember(sb, prop.DataMember, dataMemberIndex++);
wasAdded = AppendAttributes(sb, prop.Attributes) || wasAdded;
if (type.IsInterface())
{
sb.AppendLine("var {0}:{1}{2} {{ get set }}".Fmt(
prop.Name.SafeToken().PropertyStyle(), propTypeName, optional));
}
else
{
sb.AppendLine("public var {0}:{1}{2}{3}".Fmt(
prop.Name.SafeToken().PropertyStyle(), propTypeName, optional, defaultValue));
}
}
if (includeResponseStatus)
{
if (wasAdded) sb.AppendLine();
AppendDataMember(sb, null, dataMemberIndex++);
sb.AppendLine("public var {0}:ResponseStatus?".Fmt(typeof(ResponseStatus).Name.PropertyStyle()));
}
}
protected sealed override void EmitCode(NodeFactory factory, ref X64Emitter encoder, bool relocsOnly)
{
// First load the generic context into Arg0.
EmitLoadGenericContext(factory, ref encoder, relocsOnly);
switch (_id)
{
case ReadyToRunHelperId.GetNonGCStaticBase:
{
MetadataType target = (MetadataType)_target;
if (!factory.TypeSystemContext.HasLazyStaticConstructor(target))
{
EmitDictionaryLookup(factory, ref encoder, encoder.TargetRegister.Arg0, encoder.TargetRegister.Result, _lookupSignature, relocsOnly);
encoder.EmitRET();
}
else
{
EmitDictionaryLookup(factory, ref encoder, encoder.TargetRegister.Arg0, encoder.TargetRegister.Arg0, _lookupSignature, relocsOnly);
// We need to trigger the cctor before returning the base. It is stored at the beginning of the non-GC statics region.
int cctorContextSize = NonGCStaticsNode.GetClassConstructorContextStorageSize(factory.Target, target);
AddrMode loadBase = new AddrMode(encoder.TargetRegister.Arg0, null, cctorContextSize, 0, AddrModeSize.Int64);
encoder.EmitLEA(encoder.TargetRegister.Result, ref loadBase);
AddrMode initialized = new AddrMode(encoder.TargetRegister.Arg0, null, factory.Target.PointerSize, 0, AddrModeSize.Int32);
encoder.EmitCMP(ref initialized, 1);
encoder.EmitRETIfEqual();
encoder.EmitMOV(encoder.TargetRegister.Arg1, encoder.TargetRegister.Result);
encoder.EmitJMP(factory.HelperEntrypoint(HelperEntrypoint.EnsureClassConstructorRunAndReturnNonGCStaticBase));
}
}
break;
case ReadyToRunHelperId.GetGCStaticBase:
{
MetadataType target = (MetadataType)_target;
EmitDictionaryLookup(factory, ref encoder, encoder.TargetRegister.Arg0, encoder.TargetRegister.Result, _lookupSignature, relocsOnly);
AddrMode loadFromResult = new AddrMode(encoder.TargetRegister.Result, null, 0, 0, AddrModeSize.Int64);
encoder.EmitMOV(encoder.TargetRegister.Result, ref loadFromResult);
encoder.EmitMOV(encoder.TargetRegister.Result, ref loadFromResult);
if (!factory.TypeSystemContext.HasLazyStaticConstructor(target))
{
encoder.EmitRET();
}
else
{
// We need to trigger the cctor before returning the base. It is stored at the beginning of the non-GC statics region.
GenericLookupResult nonGcRegionLookup = factory.GenericLookup.TypeNonGCStaticBase(target);
EmitDictionaryLookup(factory, ref encoder, encoder.TargetRegister.Arg0, encoder.TargetRegister.Arg0, nonGcRegionLookup, relocsOnly);
AddrMode initialized = new AddrMode(encoder.TargetRegister.Arg0, null, factory.Target.PointerSize, 0, AddrModeSize.Int32);
encoder.EmitCMP(ref initialized, 1);
encoder.EmitRETIfEqual();
encoder.EmitMOV(encoder.TargetRegister.Arg1, encoder.TargetRegister.Result);
encoder.EmitJMP(factory.HelperEntrypoint(HelperEntrypoint.EnsureClassConstructorRunAndReturnGCStaticBase));
}
}
break;
case ReadyToRunHelperId.GetThreadStaticBase:
{
MetadataType target = (MetadataType)_target;
// Look up the index cell
EmitDictionaryLookup(factory, ref encoder, encoder.TargetRegister.Arg0, encoder.TargetRegister.Arg1, _lookupSignature, relocsOnly);
ISymbolNode helperEntrypoint;
if (factory.TypeSystemContext.HasLazyStaticConstructor(target))
{
// There is a lazy class constructor. We need the non-GC static base because that's where the
// class constructor context lives.
GenericLookupResult nonGcRegionLookup = factory.GenericLookup.TypeNonGCStaticBase(target);
EmitDictionaryLookup(factory, ref encoder, encoder.TargetRegister.Arg0, encoder.TargetRegister.Arg2, nonGcRegionLookup, relocsOnly);
helperEntrypoint = factory.HelperEntrypoint(HelperEntrypoint.EnsureClassConstructorRunAndReturnThreadStaticBase);
}
else
{
helperEntrypoint = factory.HelperEntrypoint(HelperEntrypoint.GetThreadStaticBaseForType);
}
// First arg: address of the TypeManager slot that provides the helper with
// information about module index and the type manager instance (which is used
// for initialization on first access).
AddrMode loadFromArg1 = new AddrMode(encoder.TargetRegister.Arg1, null, 0, 0, AddrModeSize.Int64);
encoder.EmitMOV(encoder.TargetRegister.Arg0, ref loadFromArg1);
// Second arg: index of the type in the ThreadStatic section of the modules
AddrMode loadFromArg1AndDelta = new AddrMode(encoder.TargetRegister.Arg1, null, factory.Target.PointerSize, 0, AddrModeSize.Int64);
encoder.EmitMOV(encoder.TargetRegister.Arg1, ref loadFromArg1AndDelta);
encoder.EmitJMP(helperEntrypoint);
}
break;
// These are all simple: just get the thing from the dictionary and we're done
case ReadyToRunHelperId.TypeHandle:
case ReadyToRunHelperId.MethodDictionary:
case ReadyToRunHelperId.VirtualCall:
case ReadyToRunHelperId.ResolveVirtualFunction:
case ReadyToRunHelperId.MethodEntry:
{
EmitDictionaryLookup(factory, ref encoder, encoder.TargetRegister.Arg0, encoder.TargetRegister.Result, _lookupSignature, relocsOnly);
encoder.EmitRET();
}
break;
default:
throw new NotImplementedException();
}
}
internal Metadata(string path, MetadataType type, MetadataFormat format, string version, string schema)
{
_path = path;
Type = type;
Format = format;
Version = version;
Schema = schema;
State = MetadataState.Initialized;
}
internal static MarshallerKind GetMarshallerKind(
TypeDesc type,
MarshalAsDescriptor marshalAs,
bool isReturn,
bool isAnsi,
MarshallerType marshallerType,
out MarshallerKind elementMarshallerKind)
{
if (type.IsByRef)
{
type = type.GetParameterType();
}
TypeSystemContext context = type.Context;
NativeTypeKind nativeType = NativeTypeKind.Invalid;
bool isField = marshallerType == MarshallerType.Field;
if (marshalAs != null)
{
nativeType = (NativeTypeKind)marshalAs.Type;
}
elementMarshallerKind = MarshallerKind.Invalid;
//
// Determine MarshalerKind
//
// This mostly resembles desktop CLR and .NET Native code as we need to match their behavior
//
if (type.IsPrimitive)
{
switch (type.Category)
{
case TypeFlags.Void:
return(MarshallerKind.VoidReturn);
case TypeFlags.Boolean:
switch (nativeType)
{
case NativeTypeKind.Invalid:
case NativeTypeKind.Boolean:
return(MarshallerKind.Bool);
case NativeTypeKind.U1:
case NativeTypeKind.I1:
return(MarshallerKind.CBool);
default:
return(MarshallerKind.Invalid);
}
case TypeFlags.Char:
switch (nativeType)
{
case NativeTypeKind.I1:
case NativeTypeKind.U1:
return(MarshallerKind.AnsiChar);
case NativeTypeKind.I2:
case NativeTypeKind.U2:
return(MarshallerKind.UnicodeChar);
case NativeTypeKind.Invalid:
if (isAnsi)
{
return(MarshallerKind.AnsiChar);
}
else
{
return(MarshallerKind.UnicodeChar);
}
default:
return(MarshallerKind.Invalid);
}
case TypeFlags.SByte:
case TypeFlags.Byte:
if (nativeType == NativeTypeKind.I1 || nativeType == NativeTypeKind.U1 || nativeType == NativeTypeKind.Invalid)
{
return(MarshallerKind.BlittableValue);
}
else
{
return(MarshallerKind.Invalid);
}
case TypeFlags.Int16:
case TypeFlags.UInt16:
if (nativeType == NativeTypeKind.I2 || nativeType == NativeTypeKind.U2 || nativeType == NativeTypeKind.Invalid)
{
return(MarshallerKind.BlittableValue);
}
else
{
return(MarshallerKind.Invalid);
}
case TypeFlags.Int32:
case TypeFlags.UInt32:
if (nativeType == NativeTypeKind.I4 || nativeType == NativeTypeKind.U4 || nativeType == NativeTypeKind.Invalid)
{
return(MarshallerKind.BlittableValue);
}
else
{
return(MarshallerKind.Invalid);
}
case TypeFlags.Int64:
case TypeFlags.UInt64:
if (nativeType == NativeTypeKind.I8 || nativeType == NativeTypeKind.U8 || nativeType == NativeTypeKind.Invalid)
{
return(MarshallerKind.BlittableValue);
}
else
{
return(MarshallerKind.Invalid);
}
case TypeFlags.IntPtr:
case TypeFlags.UIntPtr:
if (nativeType == NativeTypeKind.Invalid)
{
return(MarshallerKind.BlittableValue);
}
else
{
return(MarshallerKind.Invalid);
}
case TypeFlags.Single:
if (nativeType == NativeTypeKind.R4 || nativeType == NativeTypeKind.Invalid)
{
return(MarshallerKind.BlittableValue);
}
else
{
return(MarshallerKind.Invalid);
}
case TypeFlags.Double:
if (nativeType == NativeTypeKind.R8 || nativeType == NativeTypeKind.Invalid)
{
return(MarshallerKind.BlittableValue);
}
else
{
return(MarshallerKind.Invalid);
}
default:
return(MarshallerKind.Invalid);
}
}
else if (type.IsValueType)
{
if (type.IsEnum)
{
return(MarshallerKind.Enum);
}
if (InteropTypes.IsSystemDateTime(context, type))
{
if (nativeType == NativeTypeKind.Invalid ||
nativeType == NativeTypeKind.Struct)
{
return(MarshallerKind.OleDateTime);
}
else
{
return(MarshallerKind.Invalid);
}
}
/*
* TODO: Bring HandleRef to CoreLib
* https://github.com/dotnet/corert/issues/2570
*
* else if (context.IsHandleRef(type))
* {
* if (nativeType == NativeType.Invalid)
* return MarshallerKind.HandleRef;
* else
* return MarshallerKind.Invalid;
* }
*/
switch (nativeType)
{
case NativeTypeKind.Invalid:
case NativeTypeKind.Struct:
if (InteropTypes.IsSystemDecimal(context, type))
{
return(MarshallerKind.Decimal);
}
break;
case NativeTypeKind.LPStruct:
if (InteropTypes.IsSystemGuid(context, type) ||
InteropTypes.IsSystemDecimal(context, type))
{
if (isField || isReturn)
{
return(MarshallerKind.Invalid);
}
else
{
return(MarshallerKind.BlittableStructPtr);
}
}
break;
default:
return(MarshallerKind.Invalid);
}
if (type is MetadataType)
{
MetadataType metadataType = (MetadataType)type;
// the struct type need to be either sequential or explicit. If it is
// auto layout we will throw exception.
if (!metadataType.IsSequentialLayout && !metadataType.IsExplicitLayout)
{
throw new InvalidProgramException("The specified structure " + metadataType.Name + " has invalid StructLayout information. It must be either Sequential or Explicit.");
}
}
if (MarshalHelpers.IsBlittableType(type))
{
return(MarshallerKind.BlittableStruct);
}
else
{
return(MarshallerKind.Struct);
}
}
else // !ValueType
{
if (type.Category == TypeFlags.Class)
{
if (type.IsString)
{
switch (nativeType)
{
case NativeTypeKind.LPWStr:
return(MarshallerKind.UnicodeString);
case NativeTypeKind.LPStr:
return(MarshallerKind.AnsiString);
case NativeTypeKind.LPTStr:
return(MarshallerKind.UnicodeString);
case NativeTypeKind.ByValTStr:
if (isAnsi)
{
elementMarshallerKind = MarshallerKind.AnsiChar;
return(MarshallerKind.ByValAnsiString);
}
else
{
elementMarshallerKind = MarshallerKind.UnicodeChar;
return(MarshallerKind.ByValUnicodeString);
}
case NativeTypeKind.Invalid:
if (isAnsi)
{
return(MarshallerKind.AnsiString);
}
else
{
return(MarshallerKind.UnicodeString);
}
default:
return(MarshallerKind.Invalid);
}
}
else if (type.IsDelegate)
{
if (nativeType == NativeTypeKind.Invalid || nativeType == NativeTypeKind.Func)
{
return(MarshallerKind.FunctionPointer);
}
else
{
return(MarshallerKind.Invalid);
}
}
else if (type.IsObject)
{
if (nativeType == NativeTypeKind.Invalid)
{
return(MarshallerKind.Variant);
}
else
{
return(MarshallerKind.Invalid);
}
}
else if (InteropTypes.IsStringBuilder(context, type))
{
switch (nativeType)
{
case NativeTypeKind.Invalid:
if (isAnsi)
{
return(MarshallerKind.AnsiStringBuilder);
}
else
{
return(MarshallerKind.UnicodeStringBuilder);
}
case NativeTypeKind.LPStr:
return(MarshallerKind.AnsiStringBuilder);
case NativeTypeKind.LPWStr:
return(MarshallerKind.UnicodeStringBuilder);
default:
return(MarshallerKind.Invalid);
}
}
else if (InteropTypes.IsSafeHandle(context, type))
{
if (nativeType == NativeTypeKind.Invalid)
{
return(MarshallerKind.SafeHandle);
}
else
{
return(MarshallerKind.Invalid);
}
}
/*
* TODO: Bring CriticalHandle to CoreLib
* https://github.com/dotnet/corert/issues/2570
*
* else if (InteropTypes.IsCriticalHandle(context, type))
* {
* if (nativeType != NativeType.Invalid || isField)
* {
* return MarshallerKind.Invalid;
* }
* else
* {
* return MarshallerKind.CriticalHandle;
* }
* }
*/
return(MarshallerKind.Invalid);
}
else if (InteropTypes.IsSystemArray(context, type))
{
return(MarshallerKind.Invalid);
}
else if (type.IsSzArray)
{
if (nativeType == NativeTypeKind.Invalid)
{
nativeType = NativeTypeKind.Array;
}
switch (nativeType)
{
case NativeTypeKind.Array:
{
if (isField || isReturn)
{
return(MarshallerKind.Invalid);
}
var arrayType = (ArrayType)type;
elementMarshallerKind = GetArrayElementMarshallerKind(
arrayType,
marshalAs,
isAnsi);
// If element is invalid type, the array itself is invalid
if (elementMarshallerKind == MarshallerKind.Invalid)
{
return(MarshallerKind.Invalid);
}
if (elementMarshallerKind == MarshallerKind.AnsiChar)
{
return(MarshallerKind.AnsiCharArray);
}
else if (elementMarshallerKind == MarshallerKind.UnicodeChar || // Arrays of unicode char should be marshalled as blittable arrays
elementMarshallerKind == MarshallerKind.Enum ||
elementMarshallerKind == MarshallerKind.BlittableValue)
{
return(MarshallerKind.BlittableArray);
}
else
{
return(MarshallerKind.Array);
}
}
case NativeTypeKind.ByValArray: // fix sized array
{
var arrayType = (ArrayType)type;
elementMarshallerKind = GetArrayElementMarshallerKind(
arrayType,
marshalAs,
isAnsi);
// If element is invalid type, the array itself is invalid
if (elementMarshallerKind == MarshallerKind.Invalid)
{
return(MarshallerKind.Invalid);
}
if (elementMarshallerKind == MarshallerKind.AnsiChar)
{
return(MarshallerKind.ByValAnsiCharArray);
}
else
{
return(MarshallerKind.ByValArray);
}
}
default:
return(MarshallerKind.Invalid);
}
}
else if (type.Category == TypeFlags.Pointer)
{
//
// @TODO - add checks for the pointee type in case the pointee type is not blittable
// C# already does this and will emit compilation errors (can't declare pointers to
// managed type).
//
if (nativeType == NativeTypeKind.Invalid)
{
return(MarshallerKind.BlittableValue);
}
else
{
return(MarshallerKind.Invalid);
}
}
}
return(MarshallerKind.Invalid);
}
public override void SetMetadata(MetadataType type, IEnumerable<string> value)
{
parsedFile.Metadata[type] = value.ToList();
}
private string AppendType(ref StringBuilderWrapper sb, MetadataType type, string lastNS,
CreateTypeOptions options)
{
if (type == null || (type.Namespace != null && type.Namespace.StartsWith("System")))
{
return(lastNS);
}
sb = sb.Indent();
sb.AppendLine();
AppendComments(sb, type.Description);
if (type.Routes != null)
{
AppendAttributes(sb, type.Routes.ConvertAll(x => x.ToMetadataAttribute()));
}
AppendAttributes(sb, type.Attributes);
AppendDataContract(sb, type.DataContract);
if (type.IsEnum.GetValueOrDefault())
{
sb.AppendLine("enum {0}".Fmt(Type(type.Name, type.GenericArgs)));
sb.AppendLine("{");
sb = sb.Indent();
if (type.EnumNames != null)
{
for (var i = 0; i < type.EnumNames.Count; i++)
{
var name = type.EnumNames[i];
var value = type.EnumValues != null ? type.EnumValues[i] : null;
sb.AppendLine(value == null
? "{0},".Fmt(name.PropertyStyle())
: "{0} = {1},".Fmt(name.PropertyStyle(), value));
}
}
sb = sb.UnIndent();
sb.AppendLine("}");
}
else
{
var extends = new List <string>();
//: BaseClass, Interfaces
if (type.Inherits != null)
{
extends.Add(Type(type.Inherits).InheritedType());
}
if (options.ImplementsFn != null)
{
var implStr = options.ImplementsFn();
if (!string.IsNullOrEmpty(implStr))
{
extends.Add(implStr);
}
}
var extend = extends.Count > 0
? " extends " + (string.Join(", ", extends.ToArray()))
: "";
sb.AppendLine("interface {0}{1}".Fmt(Type(type.Name, type.GenericArgs), extend));
sb.AppendLine("{");
sb = sb.Indent();
var addVersionInfo = Config.AddImplicitVersion != null && options.IsOperation;
if (addVersionInfo)
{
sb.AppendLine("{0}:number; //{1}".Fmt("Version".PropertyStyle(), Config.AddImplicitVersion));
}
AddProperties(sb, type);
sb = sb.UnIndent();
sb.AppendLine("}");
}
sb = sb.UnIndent();
return(lastNS);
}
private string AppendType(ref StringBuilderWrapper sb, MetadataType type, string lastNS,
CreateTypeOptions options)
{
sb = sb.Indent();
sb.AppendLine();
AppendComments(sb, type.Description);
if (type.Routes != null)
{
AppendAttributes(sb, type.Routes.ConvertAll(x => x.ToMetadataAttribute()));
}
AppendAttributes(sb, type.Attributes);
AppendDataContract(sb, type.DataContract);
var typeName = Type(type.Name, type.GenericArgs);
if (type.IsEnum.GetValueOrDefault())
{
sb.AppendLine("public static enum {0}".Fmt(typeName));
sb.AppendLine("{");
sb = sb.Indent();
if (type.EnumNames != null)
{
var hasIntValue = false;
for (var i = 0; i < type.EnumNames.Count; i++)
{
var name = type.EnumNames[i];
var value = type.EnumValues != null ? type.EnumValues[i] : null;
var delim = i == type.EnumNames.Count - 1 ? ";" : ",";
var serializeAs = JsConfig.TreatEnumAsInteger || (type.Attributes.Safe().Any(x => x.Name == "Flags"))
? "@SerializedName(\"{0}\") ".Fmt(value)
: "";
sb.AppendLine(value == null
? "{0}{1}".Fmt(name.ToPascalCase(), delim)
: serializeAs + "{0}({1}){2}".Fmt(name.ToPascalCase(), value, delim));
hasIntValue = hasIntValue || value != null;
}
if (hasIntValue)
{
sb.AppendLine();
sb.AppendLine("private final int value;");
sb.AppendLine("{0}(final int intValue) {{ value = intValue; }}".Fmt(typeName));
sb.AppendLine("public int getValue() { return value; }");
}
}
sb = sb.UnIndent();
sb.AppendLine("}");
}
else
{
var defType = type.IsInterface()
? "interface"
: "class";
var extends = new List<string>();
//: BaseClass, Interfaces
if (type.Inherits != null)
extends.Add(Type(type.Inherits).InheritedType());
string responseTypeExpression = null;
var interfaces = new List<string>();
if (options.ImplementsFn != null)
{
var implStr = options.ImplementsFn();
if (!string.IsNullOrEmpty(implStr))
{
interfaces.Add(implStr);
if (implStr.StartsWith("IReturn<"))
{
var types = implStr.RightPart('<');
var returnType = types.Substring(0, types.Length - 1);
//Can't get .class from Generic Type definition
responseTypeExpression = returnType.Contains("<")
? "new TypeToken<{0}>(){{}}.getType()".Fmt(returnType)
: "{0}.class".Fmt(returnType);
}
}
if (!type.Implements.IsEmpty())
{
foreach (var interfaceRef in type.Implements)
{
interfaces.Add(Type(interfaceRef));
}
}
}
var extend = extends.Count > 0
? " extends " + extends[0]
: "";
if (interfaces.Count > 0)
extend += " implements " + string.Join(", ", interfaces.ToArray());
var addPropertyAccessors = Config.AddPropertyAccessors && !type.IsInterface();
var settersReturnType = addPropertyAccessors && Config.SettersReturnThis ? typeName : null;
sb.AppendLine("public static {0} {1}{2}".Fmt(defType, typeName, extend));
sb.AppendLine("{");
sb = sb.Indent();
var addVersionInfo = Config.AddImplicitVersion != null && options.IsRequest;
if (addVersionInfo)
{
sb.AppendLine("public Integer {0} = {1};".Fmt("Version".PropertyStyle(), Config.AddImplicitVersion));
if (addPropertyAccessors)
sb.AppendPropertyAccessor("Integer", "Version", settersReturnType);
}
AddProperties(sb, type,
includeResponseStatus: Config.AddResponseStatus && options.IsResponse
&& type.Properties.Safe().All(x => x.Name != typeof(ResponseStatus).Name),
addPropertyAccessors: addPropertyAccessors,
settersReturnType: settersReturnType);
if (responseTypeExpression != null)
{
sb.AppendLine("private static Object responseType = {0};".Fmt(responseTypeExpression));
sb.AppendLine("public Object getResponseType() { return responseType; }");
}
sb = sb.UnIndent();
sb.AppendLine("}");
}
sb = sb.UnIndent();
return lastNS;
}
public string GetCode(MetadataTypes metadata, IRequest request, INativeTypesMetadata nativeTypes)
{
var namespaces = new HashSet <string>();
Config.DefaultNamespaces.Each(x => namespaces.Add(x));
var typeNamespaces = new HashSet <string>();
metadata.Types.Each(x => typeNamespaces.Add(x.Namespace));
metadata.Operations.Each(x => typeNamespaces.Add(x.Request.Namespace));
// Look first for shortest Namespace ending with `ServiceModel` convention, else shortest ns
var globalNamespace = Config.GlobalNamespace
?? typeNamespaces.Where(x => x.EndsWith("ServiceModel"))
.OrderBy(x => x).FirstOrDefault()
?? typeNamespaces.OrderBy(x => x).First();
Func <string, string> defaultValue = k =>
request.QueryString[k].IsNullOrEmpty() ? "//" : "";
var sb = new StringBuilderWrapper(new StringBuilder());
sb.AppendLine("/* Options:");
sb.AppendLine("Date: {0}".Fmt(DateTime.Now.ToString("s").Replace("T", " ")));
sb.AppendLine("Version: {0}".Fmt(metadata.Version));
sb.AppendLine("BaseUrl: {0}".Fmt(Config.BaseUrl));
sb.AppendLine();
sb.AppendLine("{0}GlobalNamespace: {1}".Fmt(defaultValue("GlobalNamespace"), Config.GlobalNamespace));
sb.AppendLine("{0}AddServiceStackTypes: {1}".Fmt(defaultValue("AddServiceStackTypes"), Config.AddServiceStackTypes));
sb.AppendLine("{0}AddResponseStatus: {1}".Fmt(defaultValue("AddResponseStatus"), Config.AddResponseStatus));
sb.AppendLine("{0}AddImplicitVersion: {1}".Fmt(defaultValue("AddImplicitVersion"), Config.AddImplicitVersion));
sb.AppendLine("*/");
sb.AppendLine();
string lastNS = null;
var existingOps = new HashSet <string>();
var requestTypes = metadata.Operations.Select(x => x.Request).ToHashSet();
var requestTypesMap = metadata.Operations.ToSafeDictionary(x => x.Request);
var responseTypes = metadata.Operations
.Where(x => x.Response != null)
.Select(x => x.Response).ToHashSet();
var types = metadata.Types.ToHashSet();
var allTypes = new List <MetadataType>();
allTypes.AddRange(types);
allTypes.AddRange(responseTypes);
allTypes.AddRange(requestTypes);
//TypeScript doesn't support reusing same type name with different generic airity
var conflictPartialNames = allTypes.Map(x => x.Name).Distinct()
.GroupBy(g => g.SplitOnFirst('`')[0])
.Where(g => g.Count() > 1)
.Select(g => g.Key)
.ToList();
this.conflictTypeNames = allTypes
.Where(x => conflictPartialNames.Any(name => x.Name.StartsWith(name)))
.Map(x => x.Name);
sb.AppendLine("declare module {0}".Fmt(globalNamespace.SafeToken()));
sb.AppendLine("{");
//ServiceStack core interfaces
foreach (var type in allTypes)
{
var fullTypeName = type.GetFullName();
if (requestTypes.Contains(type))
{
if (!existingOps.Contains(fullTypeName))
{
MetadataType response = null;
MetadataOperationType operation;
if (requestTypesMap.TryGetValue(type, out operation))
{
response = operation.Response;
}
lastNS = AppendType(ref sb, type, lastNS,
new CreateTypeOptions
{
ImplementsFn = () =>
{
if (!Config.AddReturnMarker &&
!type.ReturnVoidMarker &&
type.ReturnMarkerTypeName == null)
{
return(null);
}
if (type.ReturnVoidMarker)
{
return("IReturnVoid");
}
if (type.ReturnMarkerTypeName != null)
{
return(Type("IReturn`1", new[] { Type(type.ReturnMarkerTypeName) }));
}
return(response != null
? Type("IReturn`1", new[] { Type(type.Name, type.GenericArgs) })
: null);
},
IsRequest = true,
});
existingOps.Add(fullTypeName);
}
}
else if (responseTypes.Contains(type))
{
if (!existingOps.Contains(fullTypeName) &&
!Config.IgnoreTypesInNamespaces.Contains(type.Namespace))
{
lastNS = AppendType(ref sb, type, lastNS,
new CreateTypeOptions
{
IsResponse = true,
});
existingOps.Add(fullTypeName);
}
}
else if (types.Contains(type) && !existingOps.Contains(fullTypeName))
{
lastNS = AppendType(ref sb, type, lastNS,
new CreateTypeOptions {
IsType = true
});
}
}
sb.AppendLine();
sb.AppendLine("}");
return(sb.ToString());
}