public static bool?ShouldGenericArgumentsBeIncluded(IMethod method, IAttributeStore attributeStore) { var iga = attributeStore.AttributesFor(method).GetAttribute <IncludeGenericArgumentsAttribute>(); if (iga != null) { return(iga.Include); } var imp = attributeStore.AttributesFor(method.DeclaringTypeDefinition).GetAttribute <ImportedAttribute>(); if (imp != null) { return(false); } var def = attributeStore.AttributesFor(method.ParentAssembly).GetAttribute <IncludeGenericArgumentsDefaultAttribute>(); switch (def != null ? def.MethodDefault : GenericArgumentsDefault.IncludeExceptImported) { case GenericArgumentsDefault.IncludeExceptImported: return(true); case GenericArgumentsDefault.Ignore: return(false); case GenericArgumentsDefault.RequireExplicitSpecification: return(null); default: throw new ArgumentException("Invalid generic arguments default " + def.TypeDefault); } }
private JsExpression CompileImportedTypeCheckCode(IType type, ref JsExpression @this, IRuntimeContext context, bool isTypeIs) { var def = type.GetDefinition(); if (def == null) { return(null); } var ia = _attributeStore.AttributesFor(def).GetAttribute <ImportedAttribute>(); if (ia == null || string.IsNullOrEmpty(ia.TypeCheckCode)) { return(null); } // Can ignore errors here because they are caught by the metadata importer var method = MetadataUtils.CreateTypeCheckMethod(type, _compilation); var tokens = InlineCodeMethodCompiler.Tokenize(method, ia.TypeCheckCode, _ => {}); int thisCount = tokens.Count(t => t.Type == InlineCodeToken.TokenType.This); if (!isTypeIs || thisCount > 0) { @this = context.EnsureCanBeEvaluatedMultipleTimes(@this, new JsExpression[0]); } return(JsExpression.LogicalAnd( ReferenceNotEquals(@this, JsExpression.Null, context), InlineCodeMethodCompiler.CompileExpressionInlineCodeMethodInvocation(method, tokens, @this, EmptyList <JsExpression> .Instance, n => { var t = ReflectionHelper.ParseReflectionName(n).Resolve(_compilation); return t.Kind == TypeKind.Unknown ? JsExpression.Null : InstantiateType(t, context); }, t => InstantiateTypeForUseAsTypeArgumentInInlineCode(t, context), _ => {}))); }
public static void MakeKnockoutProperty(IProperty property, IAttributeStore attributeStore) { var getter = attributeStore.AttributesFor(property.Getter); getter.ReplaceAttribute(new ScriptNameAttribute("{owner}")); getter.ReplaceAttribute(new DontGenerateAttribute()); var setter = attributeStore.AttributesFor(property.Setter); setter.ReplaceAttribute(new ScriptNameAttribute("{owner}")); setter.ReplaceAttribute(new DontGenerateAttribute()); var prop = attributeStore.AttributesFor(property); prop.ReplaceAttribute(new CustomInitializationAttribute("{$KnockoutApi.Knockout}.observable({value})")); prop.ReplaceAttribute(new BackingFieldNameAttribute("{owner}")); }
private JsType ConvertType(JsClass type) { if (type.InstanceMethods.Any(m => m.Name == "runTests")) { _errorReporter.Region = type.CSharpTypeDefinition.Region; _errorReporter.Message(MessageSeverity.Error, 7019, string.Format("The type {0} cannot define a method named 'runTests' because it has a [TestFixtureAttribute].", type.CSharpTypeDefinition.FullName)); return(type); } var instanceMethods = new List <JsMethod>(); var tests = new List <Tuple <string, string, bool, int?, JsFunctionDefinitionExpression> >(); foreach (var method in type.InstanceMethods) { var testAttr = _attributeStore.AttributesFor(method.CSharpMember).GetAttribute <TestAttribute>(); if (testAttr != null) { if (!method.CSharpMember.IsPublic || !method.CSharpMember.ReturnType.IsKnownType(KnownTypeCode.Void) || ((IMethod)method.CSharpMember).Parameters.Count > 0 || ((IMethod)method.CSharpMember).TypeParameters.Count > 0) { _errorReporter.Region = method.CSharpMember.Region; _errorReporter.Message(MessageSeverity.Error, 7020, string.Format("Method {0}: Methods decorated with a [TestAttribute] must be public, non-generic, parameterless instance methods that return void.", method.CSharpMember.FullName)); } tests.Add(Tuple.Create(testAttr.Description ?? method.CSharpMember.Name, testAttr.Category, testAttr.IsAsync, testAttr.ExpectedAssertionCount >= 0 ? (int?)testAttr.ExpectedAssertionCount : null, method.Definition)); } else { instanceMethods.Add(method); } } var testInvocations = new List <JsExpression>(); foreach (var category in tests.GroupBy(t => t.Item2).Select(g => new { Category = g.Key, Tests = g.Select(x => new { Description = x.Item1, IsAsync = x.Item3, ExpectedAssertionCount = x.Item4, Function = x.Item5 }) }).OrderBy(x => x.Category)) { if (category.Category != null) { testInvocations.Add(JsExpression.Invocation(JsExpression.Member(JsExpression.Identifier("QUnit"), "module"), JsExpression.String(category.Category))); } testInvocations.AddRange(category.Tests.Select(t => JsExpression.Invocation(JsExpression.Identifier(t.IsAsync ? "asyncTest" : "test"), t.ExpectedAssertionCount != null ? new JsExpression[] { JsExpression.String(t.Description), JsExpression.Number(t.ExpectedAssertionCount.Value), _runtimeLibrary.Bind(t.Function, JsExpression.This, this) } : new JsExpression[] { JsExpression.String(t.Description), _runtimeLibrary.Bind(t.Function, JsExpression.This, this) }))); } instanceMethods.Add(new JsMethod(null, "runTests", null, JsExpression.FunctionDefinition(new string[0], JsStatement.Block(testInvocations.Select(t => (JsStatement)t))))); var result = type.Clone(); result.InstanceMethods.Clear(); foreach (var m in instanceMethods) { result.InstanceMethods.Add(m); } return(result); }
public override void ApplyTo(IAssembly assembly, IAttributeStore attributeStore, IErrorReporter errorReporter) { foreach (var t in assembly.GetAllTypeDefinitions()) { if (!attributeStore.AttributesFor(t).HasAttribute<DefaultMemberReflectabilityAttribute>()) { ApplyTo(t, attributeStore, errorReporter); } } }
public MetadataImporter(IErrorReporter errorReporter, ICompilation compilation, IAttributeStore attributeStore, CompilerOptions options) { _errorReporter = errorReporter; _compilation = compilation; _attributeStore = attributeStore; _minimizeNames = options.MinimizeScript; _systemObject = compilation.MainAssembly.Compilation.FindType(KnownTypeCode.Object); _typeSemantics = new Dictionary<ITypeDefinition, TypeSemantics>(); _delegateSemantics = new Dictionary<ITypeDefinition, DelegateScriptSemantics>(); _instanceMemberNamesByType = new Dictionary<ITypeDefinition, HashSet<string>>(); _staticMemberNamesByType = new Dictionary<ITypeDefinition, HashSet<string>>(); _methodSemantics = new Dictionary<IMethod, MethodScriptSemantics>(); _propertySemantics = new Dictionary<IProperty, PropertyScriptSemantics>(); _fieldSemantics = new Dictionary<IField, FieldScriptSemantics>(); _eventSemantics = new Dictionary<IEvent, EventScriptSemantics>(); _constructorSemantics = new Dictionary<IMethod, ConstructorScriptSemantics>(); _propertyBackingFieldNames = new Dictionary<IProperty, Tuple<string, bool>>(); _eventBackingFieldNames = new Dictionary<IEvent, Tuple<string, bool>>(); _backingFieldCountPerType = new Dictionary<ITypeDefinition, int>(); _internalTypeCountPerAssemblyAndNamespace = new Dictionary<Tuple<IAssembly, string>, int>(); _ignoredMembers = new HashSet<IMember>(); var sna = _attributeStore.AttributesFor(compilation.MainAssembly).GetAttribute<ScriptNamespaceAttribute>(); if (sna != null) { if (sna.Name == null || (sna.Name != "" && !sna.Name.IsValidNestedJavaScriptIdentifier())) { Message(Messages._7002, default(DomRegion), "assembly"); } } }
private JsExpression GetMetadataDescriptor(ITypeDefinition type, bool isGenericSpecialization) { var properties = new List <JsObjectLiteralProperty>(); var scriptableAttributes = MetadataUtils.GetScriptableAttributes(type.Attributes, _metadataImporter).ToList(); if (scriptableAttributes.Count != 0) { properties.Add(new JsObjectLiteralProperty("attr", JsExpression.ArrayLiteral(scriptableAttributes.Select(a => MetadataUtils.ConstructAttribute(a, type, _compilation, _metadataImporter, _namer, _runtimeLibrary, _errorReporter))))); } if (type.Kind == TypeKind.Interface && MetadataUtils.IsJsGeneric(type, _metadataImporter) && type.TypeParameters != null && type.TypeParameters.Any(typeParameter => typeParameter.Variance != VarianceModifier.Invariant)) { properties.Add(new JsObjectLiteralProperty("variance", JsExpression.ArrayLiteral(type.TypeParameters.Select(typeParameter => JsExpression.Number(ConvertVarianceToInt(typeParameter.Variance)))))); } if (type.Kind == TypeKind.Class || type.Kind == TypeKind.Struct || type.Kind == TypeKind.Interface) { var members = type.Members.Where(m => MetadataUtils.IsReflectable(m, _attributeStore)) .OrderBy(m => m, MemberOrderer.Instance) .Select(m => { _errorReporter.Region = m.Region; return(MetadataUtils.ConstructMemberInfo(m, _compilation, _metadataImporter, _namer, _runtimeLibrary, _errorReporter, t => _runtimeLibrary.InstantiateType(t, isGenericSpecialization ? _genericSpecializationReflectionRuntimeContext : _defaultReflectionRuntimeContext), includeDeclaringType: false)); }) .ToList(); if (members.Count > 0) { properties.Add(new JsObjectLiteralProperty("members", JsExpression.ArrayLiteral(members))); } var aua = _attributeStore.AttributesFor(type).GetAttribute <AttributeUsageAttribute>(); if (aua != null) { if (!aua.Inherited) { properties.Add(new JsObjectLiteralProperty("attrNoInherit", JsExpression.True)); } if (aua.AllowMultiple) { properties.Add(new JsObjectLiteralProperty("attrAllowMultiple", JsExpression.True)); } } } if (type.Kind == TypeKind.Enum && _attributeStore.AttributesFor(type).HasAttribute <FlagsAttribute>()) { properties.Add(new JsObjectLiteralProperty("enumFlags", JsExpression.True)); } return(properties.Count > 0 ? JsExpression.ObjectLiteral(properties) : null); }
public override void ApplyTo(IAssembly assembly, IAttributeStore attributeStore, IErrorReporter errorReporter) { foreach (var t in assembly.GetAllTypeDefinitions()) { if (!attributeStore.AttributesFor(t).HasAttribute <DefaultMemberReflectabilityAttribute>()) { ApplyTo(t, attributeStore, errorReporter); } } }
private void ProcessMember(IMember member) { var attributes = _attributeStore.AttributesFor(member); if (!attributes.HasAttribute <ReflectableAttribute>()) { if (member.Attributes.Any(a => a.AttributeType.Kind == TypeKind.Class && !_attributeStore.AttributesFor((IEntity)a.AttributeType.GetDefinition()).HasAttribute <NonScriptableAttribute>())) { attributes.Add(new ReflectableAttribute(true)); } } }
public static string GetModuleName(ITypeDefinition type, IAttributeStore attributeStore) { for (var current = type; current != null; current = current.DeclaringTypeDefinition) { var mna = attributeStore.AttributesFor(type).GetAttribute <ModuleNameAttribute>(); if (mna != null) { return(!String.IsNullOrEmpty(mna.ModuleName) ? mna.ModuleName : null); } } return(GetModuleName(type.ParentAssembly, attributeStore)); }
public override void ApplyTo(IEntity entity, IAttributeStore attributeStore, IErrorReporter errorReporter) { var type = entity as ITypeDefinition; if (type == null) return; foreach (var m in type.Members) { var attributes = attributeStore.AttributesFor(m); if (!attributes.HasAttribute<ReflectableAttribute>()) { if (IsMemberReflectable(m)) { attributes.Add(new ReflectableAttribute(true)); } } } }
public override void ApplyTo(IEntity entity, IAttributeStore attributeStore, IErrorReporter errorReporter) { foreach (var p in ((ITypeDefinition)entity).GetProperties(options: GetMemberOptions.IgnoreInheritedMembers)) { if (attributeStore.AttributesFor(p).HasAttribute<KnockoutPropertyAttribute>()) continue; if (p.IsStatic) continue; if (MetadataUtils.IsAutoProperty(p) == false) { errorReporter.Message(MessageSeverity.Error, 8001, "The property {0} is not an auto-property so because its containing type has a [KnockoutModelAttribute], the property must be decorated with [KnockoutPropertyAttribute(false)]", p.FullName); continue; } KnockoutPropertyAttribute.MakeKnockoutProperty(p, attributeStore); } }
public override void ApplyTo(IEntity entity, IAttributeStore attributeStore, IErrorReporter errorReporter) { var type = entity as ITypeDefinition; if (type == null) { return; } foreach (var m in type.Members) { var attributes = attributeStore.AttributesFor(m); if (!attributes.HasAttribute <ReflectableAttribute>()) { if (IsMemberReflectable(m)) { attributes.Add(new ReflectableAttribute(true)); } } } }
public override void ApplyTo(IEntity entity, IAttributeStore attributeStore, IErrorReporter errorReporter) { foreach (var p in ((ITypeDefinition)entity).GetProperties(options: GetMemberOptions.IgnoreInheritedMembers)) { if (attributeStore.AttributesFor(p).HasAttribute <KnockoutPropertyAttribute>()) { continue; } if (p.IsStatic) { continue; } if (MetadataUtils.IsAutoProperty(p) == false) { errorReporter.Message(MessageSeverity.Error, 8001, "The property {0} is not an auto-property so because its containing type has a [KnockoutModelAttribute], the property must be decorated with [KnockoutPropertyAttribute(false)]", p.FullName); continue; } KnockoutPropertyAttribute.MakeKnockoutProperty(p, attributeStore); } }
public static bool CanBeMinimized(IMember member, IAttributeStore attributeStore) { return !member.IsExternallyVisible() || attributeStore.AttributesFor(member.ParentAssembly).HasAttribute<MinimizePublicNamesAttribute>(); }
public static IEnumerable <KeyValuePair <string, string> > GetAdditionalDependencies(IAssembly assembly, IAttributeStore attributeStore) { return(attributeStore.AttributesFor(assembly).GetAttributes <AdditionalDependencyAttribute>() .Select(a => new KeyValuePair <string, string>(a.ModuleName, a.InstanceName))); }
public static bool OmitDowncasts(ICompilation compilation, IAttributeStore attributeStore) { var sca = attributeStore.AttributesFor(compilation.MainAssembly).GetAttribute <ScriptSharpCompatibilityAttribute>(); return(sca != null && sca.OmitDowncasts); }
public static bool IsGlobalMethods(ITypeDefinition type, IAttributeStore attributeStore) { return(attributeStore.AttributesFor(type).HasAttribute <GlobalMethodsAttribute>()); }
public static bool IsResources(ITypeDefinition type, IAttributeStore attributeStore) { return(attributeStore.AttributesFor(type).HasAttribute <ResourcesAttribute>()); }
public static bool IsMixin(ITypeDefinition type, IAttributeStore attributeStore) { return(attributeStore.AttributesFor(type).HasAttribute <MixinAttribute>()); }
public static bool CanBeMinimized(IMember member, IAttributeStore attributeStore) { return(!member.IsExternallyVisible() || attributeStore.AttributesFor(member.ParentAssembly).HasAttribute <MinimizePublicNamesAttribute>()); }
public static bool IsMixin(ITypeDefinition type, IAttributeStore attributeStore) { return attributeStore.AttributesFor(type).HasAttribute<MixinAttribute>(); }
public static bool DoesTypeObeyTypeSystem(ITypeDefinition type, IAttributeStore attributeStore) { var ia = attributeStore.AttributesFor(type).GetAttribute<ImportedAttribute>(); return ia == null || ia.ObeysTypeSystem; }
public static string GetSerializableTypeCheckCode(ITypeDefinition type, IAttributeStore attributeStore) { var attr = attributeStore.AttributesFor(type).GetAttribute<ScriptSerializableAttribute>(); return attr != null ? attr.TypeCheckCode : null; }
public static bool IsSerializable(ITypeDefinition type, IAttributeStore attributeStore) { return attributeStore.AttributesFor(type).HasAttribute<ScriptSerializableAttribute>() || (type.GetAllBaseTypeDefinitions().Any(td => td.FullName == "System.Record") && type.FullName != "System.Record"); }
public static bool IsReflectable(IMember member, IAttributeStore attributeStore) { var ra = attributeStore.AttributesFor(member).GetAttribute<ReflectableAttribute>(); return ra != null && ra.Reflectable; }
/// <summary> /// Determines the preferred name for a member. The first item is the name, the second item is true if the name was explicitly specified. /// </summary> public static Tuple<string, bool> DeterminePreferredMemberName(IMember member, bool minimizeNames, IAttributeStore attributeStore) { member = UnwrapValueTypeConstructor(member); bool isConstructor = member is IMethod && ((IMethod)member).IsConstructor; bool isAccessor = member is IMethod && ((IMethod)member).IsAccessor; bool isPreserveMemberCase = IsPreserveMemberCase(member.DeclaringTypeDefinition, attributeStore); string defaultName; if (isConstructor) { defaultName = "$ctor"; } else if (!CanBeMinimized(member, attributeStore)) { defaultName = isPreserveMemberCase ? member.Name : MakeCamelCase(member.Name); } else { if (minimizeNames && member.DeclaringType.Kind != TypeKind.Interface) defaultName = null; else defaultName = "$" + (isPreserveMemberCase ? member.Name : MakeCamelCase(member.Name)); } var attributes = attributeStore.AttributesFor(member); var asa = attributes.GetAttribute<AlternateSignatureAttribute>(); if (asa != null) { var otherMembers = member.DeclaringTypeDefinition.Methods.Where(m => m.Name == member.Name && !attributeStore.AttributesFor(m).HasAttribute<AlternateSignatureAttribute>() && !attributeStore.AttributesFor(m).HasAttribute<NonScriptableAttribute>() && !attributeStore.AttributesFor(m).HasAttribute<InlineCodeAttribute>()).ToList(); if (otherMembers.Count == 1) { return DeterminePreferredMemberName(otherMembers[0], minimizeNames, attributeStore); } else { return Tuple.Create(member.Name, false); // Error } } var sna = attributes.GetAttribute<ScriptNameAttribute>(); if (sna != null) { string name = sna.Name; if (IsNamedValues(member.DeclaringTypeDefinition, attributeStore) && (name == "" || !name.IsValidJavaScriptIdentifier())) { return Tuple.Create(defaultName, false); // For named values enum, allow the use to specify an empty or invalid value, which will only be used as the literal value for the field, not for the name. } if (name == "" && isConstructor) name = "$ctor"; return Tuple.Create(name, true); } if (isConstructor && IsImported(member.DeclaringTypeDefinition, attributeStore)) { return Tuple.Create("$ctor", true); } var ica = attributes.GetAttribute<InlineCodeAttribute>(); if (ica != null) { if (ica.GeneratedMethodName != null) return Tuple.Create(ica.GeneratedMethodName, true); } if (attributes.HasAttribute<PreserveCaseAttribute>()) return Tuple.Create(member.Name, true); bool preserveName = (!isConstructor && !isAccessor && ( attributes.HasAttribute<PreserveNameAttribute>() || attributes.HasAttribute<InstanceMethodOnFirstArgumentAttribute>() || IsPreserveMemberNames(member.DeclaringTypeDefinition, attributeStore) && member.ImplementedInterfaceMembers.Count == 0 && !member.IsOverride) || (IsSerializable(member.DeclaringTypeDefinition, attributeStore) && !member.IsStatic && (member is IProperty || member is IField))) || (IsNamedValues(member.DeclaringTypeDefinition, attributeStore) && member is IField); if (preserveName) return Tuple.Create(isPreserveMemberCase ? member.Name : MakeCamelCase(member.Name), true); return Tuple.Create(defaultName, false); }
public static bool OmitDowncasts(ICompilation compilation, IAttributeStore attributeStore) { var sca = attributeStore.AttributesFor(compilation.MainAssembly).GetAttribute<ScriptSharpCompatibilityAttribute>(); return sca != null && sca.OmitDowncasts; }
public static bool IsReflectable(IMember member, IAttributeStore attributeStore) { var ra = attributeStore.AttributesFor(member).GetAttribute <ReflectableAttribute>(); return(ra != null && ra.Reflectable); }
public static string GetSerializableTypeCheckCode(ITypeDefinition type, IAttributeStore attributeStore) { var attr = attributeStore.AttributesFor(type).GetAttribute <ScriptSerializableAttribute>(); return(attr != null ? attr.TypeCheckCode : null); }
public static bool IsImported(ITypeDefinition type, IAttributeStore attributeStore) { return(attributeStore.AttributesFor(type).HasAttribute <ImportedAttribute>()); }
public static string GetModuleName(ITypeDefinition type, IAttributeStore attributeStore) { for (var current = type; current != null; current = current.DeclaringTypeDefinition) { var mna = attributeStore.AttributesFor(type).GetAttribute<ModuleNameAttribute>(); if (mna != null) return !String.IsNullOrEmpty(mna.ModuleName) ? mna.ModuleName : null; } return GetModuleName(type.ParentAssembly, attributeStore); }
public static bool IsNamedValues(ITypeDefinition type, IAttributeStore attributeStore) { return(attributeStore.AttributesFor(type).HasAttribute <NamedValuesAttribute>()); }
public static bool IsPreserveMemberCase(ITypeDefinition type, IAttributeStore attributeStore) { var pmca = attributeStore.AttributesFor(type).GetAttribute<PreserveMemberCaseAttribute>() ?? attributeStore.AttributesFor(type.ParentAssembly).GetAttribute<PreserveMemberCaseAttribute>(); return pmca != null && pmca.Preserve; }
public static bool IsPreserveMemberCase(ITypeDefinition type, IAttributeStore attributeStore) { var pmca = attributeStore.AttributesFor(type).GetAttribute <PreserveMemberCaseAttribute>() ?? attributeStore.AttributesFor(type.ParentAssembly).GetAttribute <PreserveMemberCaseAttribute>(); return(pmca != null && pmca.Preserve); }
public static string GetModuleName(IAssembly assembly, IAttributeStore attributeStore) { var mna = attributeStore.AttributesFor(assembly).GetAttribute<ModuleNameAttribute>(); return (mna != null && !String.IsNullOrEmpty(mna.ModuleName) ? mna.ModuleName : null); }
public static bool IsAsyncModule(IAssembly assembly, IAttributeStore attributeStore) { return(attributeStore.AttributesFor(assembly).HasAttribute <AsyncModuleAttribute>()); }
public static IEnumerable<KeyValuePair<string,string>> GetAdditionalDependencies(IAssembly assembly, IAttributeStore attributeStore) { return attributeStore.AttributesFor(assembly).GetAttributes<AdditionalDependencyAttribute>() .Select(a => new KeyValuePair<string,string>(a.ModuleName, a.InstanceName)); }
public static string GetModuleName(IAssembly assembly, IAttributeStore attributeStore) { var mna = attributeStore.AttributesFor(assembly).GetAttribute <ModuleNameAttribute>(); return(mna != null && !String.IsNullOrEmpty(mna.ModuleName) ? mna.ModuleName : null); }
public static bool IsAsyncModule(IAssembly assembly, IAttributeStore attributeStore) { return attributeStore.AttributesFor(assembly).HasAttribute<AsyncModuleAttribute>(); }
public static bool IsImported(ITypeDefinition type, IAttributeStore attributeStore) { return attributeStore.AttributesFor(type).HasAttribute<ImportedAttribute>(); }
public static bool? ShouldGenericArgumentsBeIncluded(IMethod method, IAttributeStore attributeStore) { var iga = attributeStore.AttributesFor(method).GetAttribute<IncludeGenericArgumentsAttribute>(); if (iga != null) return iga.Include; var imp = attributeStore.AttributesFor(method.DeclaringTypeDefinition).GetAttribute<ImportedAttribute>(); if (imp != null) return false; var def = attributeStore.AttributesFor(method.ParentAssembly).GetAttribute<IncludeGenericArgumentsDefaultAttribute>(); switch (def != null ? def.MethodDefault : GenericArgumentsDefault.IncludeExceptImported) { case GenericArgumentsDefault.IncludeExceptImported: return true; case GenericArgumentsDefault.Ignore: return false; case GenericArgumentsDefault.RequireExplicitSpecification: return null; default: throw new ArgumentException("Invalid generic arguments default " + def.TypeDefault); } }
/// <summary> /// Determines the preferred name for a member. The first item is the name, the second item is true if the name was explicitly specified. /// </summary> public static Tuple <string, bool> DeterminePreferredMemberName(IMember member, bool minimizeNames, IAttributeStore attributeStore) { member = UnwrapValueTypeConstructor(member); bool isConstructor = member is IMethod && ((IMethod)member).IsConstructor; bool isAccessor = member is IMethod && ((IMethod)member).IsAccessor; bool isPreserveMemberCase = IsPreserveMemberCase(member.DeclaringTypeDefinition, attributeStore); string defaultName; if (isConstructor) { defaultName = "$ctor"; } else if (!CanBeMinimized(member, attributeStore)) { defaultName = isPreserveMemberCase ? member.Name : MakeCamelCase(member.Name); } else { if (minimizeNames && member.DeclaringType.Kind != TypeKind.Interface) { defaultName = null; } else { defaultName = "$" + (isPreserveMemberCase ? member.Name : MakeCamelCase(member.Name)); } } var attributes = attributeStore.AttributesFor(member); var asa = attributes.GetAttribute <AlternateSignatureAttribute>(); if (asa != null) { var otherMembers = member.DeclaringTypeDefinition.Methods.Where(m => m.Name == member.Name && !attributeStore.AttributesFor(m).HasAttribute <AlternateSignatureAttribute>() && !attributeStore.AttributesFor(m).HasAttribute <NonScriptableAttribute>() && !attributeStore.AttributesFor(m).HasAttribute <InlineCodeAttribute>()).ToList(); if (otherMembers.Count == 1) { return(DeterminePreferredMemberName(otherMembers[0], minimizeNames, attributeStore)); } else { return(Tuple.Create(member.Name, false)); // Error } } var sna = attributes.GetAttribute <ScriptNameAttribute>(); if (sna != null) { string name = sna.Name; if (IsNamedValues(member.DeclaringTypeDefinition, attributeStore) && (name == "" || !name.IsValidJavaScriptIdentifier())) { return(Tuple.Create(defaultName, false)); // For named values enum, allow the use to specify an empty or invalid value, which will only be used as the literal value for the field, not for the name. } if (name == "" && isConstructor) { name = "$ctor"; } return(Tuple.Create(name, true)); } if (isConstructor && IsImported(member.DeclaringTypeDefinition, attributeStore)) { return(Tuple.Create("$ctor", true)); } var ica = attributes.GetAttribute <InlineCodeAttribute>(); if (ica != null) { if (ica.GeneratedMethodName != null) { return(Tuple.Create(ica.GeneratedMethodName, true)); } } if (attributes.HasAttribute <PreserveCaseAttribute>()) { return(Tuple.Create(member.Name, true)); } bool preserveName = (!isConstructor && !isAccessor && (attributes.HasAttribute <PreserveNameAttribute>() || attributes.HasAttribute <InstanceMethodOnFirstArgumentAttribute>() || IsPreserveMemberNames(member.DeclaringTypeDefinition, attributeStore) && member.ImplementedInterfaceMembers.Count == 0 && !member.IsOverride) || (IsSerializable(member.DeclaringTypeDefinition, attributeStore) && !member.IsStatic && (member is IProperty || member is IField))) || (IsNamedValues(member.DeclaringTypeDefinition, attributeStore) && member is IField); if (preserveName) { return(Tuple.Create(isPreserveMemberCase ? member.Name : MakeCamelCase(member.Name), true)); } return(Tuple.Create(defaultName, false)); }
public static bool IsResources(ITypeDefinition type, IAttributeStore attributeStore) { return attributeStore.AttributesFor(type).HasAttribute<ResourcesAttribute>(); }
public static bool IsSerializable(ITypeDefinition type, IAttributeStore attributeStore) { return(attributeStore.AttributesFor(type).HasAttribute <ScriptSerializableAttribute>() || (type.GetAllBaseTypeDefinitions().Any(td => td.FullName == "System.Record") && type.FullName != "System.Record")); }
public static bool IsNamedValues(ITypeDefinition type, IAttributeStore attributeStore) { return attributeStore.AttributesFor(type).HasAttribute<NamedValuesAttribute>(); }
public static bool DoesTypeObeyTypeSystem(ITypeDefinition type, IAttributeStore attributeStore) { var ia = attributeStore.AttributesFor(type).GetAttribute <ImportedAttribute>(); return(ia == null || ia.ObeysTypeSystem); }
public static bool IsGlobalMethods(ITypeDefinition type, IAttributeStore attributeStore) { return attributeStore.AttributesFor(type).HasAttribute<GlobalMethodsAttribute>(); }