private static void FindTypeUsageErrors(IEnumerable<IType> types, IMetadataImporter metadataImporter, HashSet<ITypeDefinition> usedUnusableTypes, HashSet<ITypeDefinition> mutableValueTypesBoundToTypeArguments) {
foreach (var t in types) {
if (t is ITypeDefinition) {
if (metadataImporter.GetTypeSemantics((ITypeDefinition)t).Type == TypeScriptSemantics.ImplType.NotUsableFromScript)
usedUnusableTypes.Add((ITypeDefinition)t);
}
else if (t is ParameterizedType) {
var pt = (ParameterizedType)t;
foreach (var ta in pt.TypeArguments) {
if (ta.Kind == TypeKind.Struct && metadataImporter.GetTypeSemantics(ta.GetDefinition()).Type == TypeScriptSemantics.ImplType.MutableValueType)
mutableValueTypesBoundToTypeArguments.Add(ta.GetDefinition());
}
FindTypeUsageErrors(new[] { pt.GetDefinition() }.Concat(pt.TypeArguments), metadataImporter, usedUnusableTypes, mutableValueTypesBoundToTypeArguments);
}
}
}
private static void FindUsedUnusableTypes(IEnumerable<IType> types, IMetadataImporter metadataImporter, HashSet<ITypeDefinition> result) {
foreach (var t in types) {
if (t is ITypeDefinition) {
if (metadataImporter.GetTypeSemantics((ITypeDefinition)t).Type == TypeScriptSemantics.ImplType.NotUsableFromScript)
result.Add((ITypeDefinition)t);
}
else if (t is ParameterizedType) {
var pt = (ParameterizedType)t;
FindUsedUnusableTypes(new[] { pt.GetDefinition() }.Concat(pt.TypeArguments), metadataImporter, result);
}
}
}
public static UnusableTypesResult FindGenericInstantiationErrors(IEnumerable<IType> typeArguments, IMetadataImporter metadataImporter) {
if (!(typeArguments is ICollection<IType>))
typeArguments = typeArguments.ToList();
var usedUnusableTypes = new HashSet<ITypeDefinition>();
var mutableValueTypesBoundToTypeArguments = new HashSet<ITypeDefinition>();
foreach (var ta in typeArguments) {
if (ta.Kind == TypeKind.Struct && metadataImporter.GetTypeSemantics(ta.GetDefinition()).Type == TypeScriptSemantics.ImplType.MutableValueType)
mutableValueTypesBoundToTypeArguments.Add(ta.GetDefinition());
}
FindTypeUsageErrors(typeArguments, metadataImporter, usedUnusableTypes, mutableValueTypesBoundToTypeArguments);
return new UnusableTypesResult(usedUnusableTypes.Count > 0 ? usedUnusableTypes.ToList<IType>() : (IList<IType>)EmptyList<IType>.Instance, mutableValueTypesBoundToTypeArguments.Count > 0 ? mutableValueTypesBoundToTypeArguments.ToList<IType>() : (IList<IType>)EmptyList<IType>.Instance);
}
public static UnusableTypesResult FindGenericInstantiationErrors(IEnumerable <IType> typeArguments, IMetadataImporter metadataImporter)
{
if (!(typeArguments is ICollection <IType>))
{
typeArguments = typeArguments.ToList();
}
var usedUnusableTypes = new HashSet <ITypeDefinition>();
var mutableValueTypesBoundToTypeArguments = new HashSet <ITypeDefinition>();
foreach (var ta in typeArguments)
{
if (ta.Kind == TypeKind.Struct && metadataImporter.GetTypeSemantics(ta.GetDefinition()).Type == TypeScriptSemantics.ImplType.MutableValueType)
{
mutableValueTypesBoundToTypeArguments.Add(ta.GetDefinition());
}
}
FindTypeUsageErrors(typeArguments, metadataImporter, usedUnusableTypes, mutableValueTypesBoundToTypeArguments);
return(new UnusableTypesResult(usedUnusableTypes.Count > 0 ? usedUnusableTypes.ToList <IType>() : (IList <IType>)EmptyList <IType> .Instance, mutableValueTypesBoundToTypeArguments.Count > 0 ? mutableValueTypesBoundToTypeArguments.ToList <IType>() : (IList <IType>)EmptyList <IType> .Instance));
}
private IEnumerable <JsStatement> GetStaticInitCode(IEnumerable <JsType> types)
{
return(GetStaticInitializationOrder(OrderByNamespace(types.OfType <JsClass>(), c => _metadataImporter.GetTypeSemantics(c.CSharpTypeDefinition).Name), 1)
.SelectMany(_emulator.GetStaticInitStatements));
}
public static bool IsReflectable(IMember member, IMetadataImporter metadataImporter)
{
return(member.Attributes.Any(a => a.AttributeType.FullName == typeof(ReflectableAttribute).FullName || metadataImporter.GetTypeSemantics(a.AttributeType.GetDefinition()).Type == TypeScriptSemantics.ImplType.NormalType));
}
public static IEnumerable<IAttribute> GetScriptableAttributes(IEnumerable<IAttribute> attributes, IMetadataImporter metadataImporter) {
return attributes.Where(a => !a.IsConditionallyRemoved && metadataImporter.GetTypeSemantics(a.AttributeType.GetDefinition()).Type != TypeScriptSemantics.ImplType.NotUsableFromScript);
}
public static bool IsReflectable(IMember member, IMetadataImporter metadataImporter) {
var ra = AttributeReader.ReadAttribute<ReflectableAttribute>(member);
if (ra != null)
return ra.Reflectable;
if (member.Attributes.Any(a => metadataImporter.GetTypeSemantics(a.AttributeType.GetDefinition()).Type != TypeScriptSemantics.ImplType.NotUsableFromScript))
return true; // Any scriptable attribute will cause reflectability (unless [Reflectable(false)] was specified.
if (member.DeclaringType.Kind != TypeKind.Anonymous) {
var tdr = AttributeReader.ReadAttribute<DefaultMemberReflectabilityAttribute>(member.DeclaringTypeDefinition);
if (tdr != null) {
return IsMemberReflectable(member, tdr.DefaultReflectability);
}
var adr = AttributeReader.ReadAttribute<DefaultMemberReflectabilityAttribute>(member.ParentAssembly.AssemblyAttributes);
if (adr != null) {
return IsMemberReflectable(member, adr.DefaultReflectability);
}
}
return false;
}
public static bool IsJsGeneric(ITypeDefinition type, IMetadataImporter metadataImporter) {
return type.TypeParameterCount > 0 && !metadataImporter.GetTypeSemantics(type).IgnoreGenericArguments;
}
private static List<JsObjectLiteralProperty> GetCommonMemberInfoProperties(IMember m, ICompilation compilation, IMetadataImporter metadataImporter, INamer namer, IRuntimeLibrary runtimeLibrary, IErrorReporter errorReporter, Func<IType, JsExpression> instantiateType, bool includeDeclaringType) {
var result = new List<JsObjectLiteralProperty>();
var attr = m.Attributes.Where(a => !a.IsConditionallyRemoved && metadataImporter.GetTypeSemantics(a.AttributeType.GetDefinition()).Type == TypeScriptSemantics.ImplType.NormalType).ToList();
if (attr.Count > 0)
result.Add(new JsObjectLiteralProperty("attr", JsExpression.ArrayLiteral(attr.Select(a => ConstructAttribute(a, m.DeclaringTypeDefinition, compilation, metadataImporter, namer, runtimeLibrary, errorReporter)))));
if (includeDeclaringType)
result.Add(new JsObjectLiteralProperty("typeDef", instantiateType(m.DeclaringType)));
result.Add(new JsObjectLiteralProperty("name", JsExpression.String(m.Name)));
return result;
}
public static bool IsMutableValueType(IType type, IMetadataImporter metadataImporter)
{
return(type.Kind == TypeKind.Struct && metadataImporter.GetTypeSemantics(type.GetDefinition()).Type == TypeScriptSemantics.ImplType.MutableValueType);
}
public virtual TypeScriptSemantics GetTypeSemantics(ITypeDefinition typeDefinition)
{
return(_prev.GetTypeSemantics(typeDefinition));
}
public static JsExpression ResolveTypeParameter(ITypeParameter tp, ITypeDefinition currentType, IMethod currentMethod, IMetadataImporter metadataImporter, IErrorReporter errorReporter, INamer namer) {
bool unusable = false;
switch (tp.OwnerType) {
case EntityType.TypeDefinition:
unusable = metadataImporter.GetTypeSemantics(currentType).IgnoreGenericArguments;
break;
case EntityType.Method: {
var sem = metadataImporter.GetMethodSemantics(currentMethod);
unusable = sem.Type != MethodScriptSemantics.ImplType.InlineCode && metadataImporter.GetMethodSemantics(currentMethod).IgnoreGenericArguments;
break;
}
default:
errorReporter.InternalError("Invalid owner " + tp.OwnerType + " for type parameter " + tp);
return JsExpression.Null;
}
if (unusable) {
errorReporter.Message(Messages._7536, tp.Name, tp.OwnerType == EntityType.TypeDefinition ? "type" : "method", tp.OwnerType == EntityType.TypeDefinition ? currentType.FullName : currentMethod.FullName);
return JsExpression.Null;
}
return JsExpression.Identifier(namer.GetTypeParameterName(tp));
}
public static bool IsJsGeneric(ITypeDefinition type, IMetadataImporter metadataImporter)
{
return(type.TypeParameterCount > 0 && !metadataImporter.GetTypeSemantics(type).IgnoreGenericArguments);
}
public static bool IsReflectable(IMember member, IMetadataImporter metadataImporter) {
return member.Attributes.Any(a => a.AttributeType.FullName == typeof(ReflectableAttribute).FullName || metadataImporter.GetTypeSemantics(a.AttributeType.GetDefinition()).Type == TypeScriptSemantics.ImplType.NormalType);
}
public static IEnumerable <IAttribute> GetScriptableAttributes(IEnumerable <IAttribute> attributes, IMetadataImporter metadataImporter)
{
return(attributes.Where(a => !a.IsConditionallyRemoved && metadataImporter.GetTypeSemantics(a.AttributeType.GetDefinition()).Type != TypeScriptSemantics.ImplType.NotUsableFromScript));
}
public static bool IsMutableValueType(IType type, IMetadataImporter metadataImporter) {
return type.Kind == TypeKind.Struct && metadataImporter.GetTypeSemantics(type.GetDefinition()).Type == TypeScriptSemantics.ImplType.MutableValueType;
}
