public static bool IsVisible(this ITypeMember member) { var declType = member.DeclaringType; if (declType != null && !declType.IsVisible()) { return(false); } var type = member as IType; if (type != null) { if (type.ElementType != null) { return(type.ElementType.IsVisible()); } if (type.IsGenericInstance()) { return(type.Type == null || type.Type.IsVisible()); } } switch (member.Visibility) { case Visibility.Public: case Visibility.NestedPublic: return(true); } return(false); }
private object OpLdtoken(MethodContext context, ITypeMember member) { var key = new InstructionKey(InstructionCode.Ldtoken, member); var var = context.Vars[key]; if (var != null) { return(var); } var field = member as IField; if (field != null) { if (field.IsArrayInitializer()) { var blob = field.GetBlob(); var arr = new JsArray(blob.ToArray().Select(x => (object)x)); return(context.Vars.Add(key, arr)); } throw new NotImplementedException(); } var type = member as IType; if (type != null) { CompileType(type); return(type.FullName); } throw new NotImplementedException(); }
public AbcTrait Find(ITypeMember member) { var key = KeyOf(member); AbcTrait trait; return(_cache.TryGetValue(key, out trait) ? trait : null); }
public override string GetCLRTypeName(ITypeMember m) { switch (m.PassedByType) { case PassedByType.Value: return(Name); case PassedByType.Pointer: if (IsVoid) { return("void*"); } if (m.HasAttribute <ArrayTypeAttribute>()) { return("array<" + FullyQualifiedCLRName + ">^"); } string name = Name + "*"; if (m.IsConst) { name = "const " + name; } return(name); default: throw new Exception("Unexpected"); } }
public void CheckApiCompatibility(ITypeMember m) { if (m == null) { return; } if (!IsSwf) { return; } int v = m.GetPlayerVersion(); if (v < 0) { return; } if (v > PlayerVersion) { var method = m as IMethod; if (method != null) { CompilerReport.Add(Errors.ABC.IncompatibleCall, method.GetFullName(), v); return; } var f = m as IField; if (f != null) { CompilerReport.Add(Errors.ABC.IncompatibleField, f.GetFullName(), v); return; } } }
public void GenerateMembers <T>(Type element, TypeResolver resolver, ITypeMember typeMember, IEnumerable <T> members, ExportContext exportContext) where T : MemberInfo { this.typeMember = typeMember; this.exportContext = exportContext; foreach (var m in members) { Actual.AddGeneratorType(m); var generator = exportContext.Generators.GeneratorFor(m); var member = generator.Generate(m, resolver); switch (m.MemberType) { case MemberTypes.Field: GeneratedField(member, m as FieldInfo); break; case MemberTypes.Property: GeneratedProperty(member, m as PropertyInfo); break; case MemberTypes.Method: GeneratedMethod(member, m as MethodInfo); break; case MemberTypes.Constructor: GeneratedConstructor(member, m as ConstructorInfo); break; } } }
public override string GetCLRTypeName(ITypeMember m) { switch (m.PassedByType) { case PassedByType.Reference: case PassedByType.Pointer: if (m.IsConst) { return(FullyQualifiedCLRName.Replace(CLRName, "Const_" + CLRName) + "^"); } return(FullyQualifiedCLRName + "^"); case PassedByType.Value: if (m.IsConst || IsReadOnly) { return(FullyQualifiedCLRName.Replace(CLRName, "Const_" + CLRName) + "^"); } return(FullyQualifiedCLRName + "^"); default: throw new Exception("Unexpected"); } }
//cannot create a new ITypeMember and add the Type to it public void GenerateMembers <T>(TypeResolver resolver, ITypeMember typeMember, IEnumerable <T> members, GeneratorManager Generators) where T : MemberInfo { foreach (var m in members) { var generator = Generators.GeneratorFor(m); var member = generator.Generate(m, resolver); if (member != null) { RtNode wrapperNode = null; switch (m.MemberType) { case MemberTypes.Field: wrapperNode = new ReflectionAttachedRtField(member as RtField, m as FieldInfo); break; case MemberTypes.Property: wrapperNode = new ReflectionAttachedRtField(member as RtField, m as PropertyInfo); break; case MemberTypes.Method: wrapperNode = new ReflectionAttachedRtFunction(member as RtFunction, m as MethodInfo); break; case MemberTypes.Constructor: wrapperNode = new ReflectionAttachedRtConstructor(member as RtConstructor, m as ConstructorInfo); break; } typeMember.Members.Add(wrapperNode); } } }
private static bool IsTheoryPropertyDataProperty(ITypeMember element) { if (element.IsStatic && element.GetAccessRights() == AccessRights.PUBLIC) { // Make sure there is a containing type. The only example I've seen where this is null // is when the C# class is included in the project, but not compiled (i.e. build action // is set to None). Not sure if this is a bug or not - on the one hand, it's not compiled // so there isn't really a type there, on the other, there's enough info for it to be // a method, and that method has to live somewhere. Either way, we don't care. If it's // not compiled, it's no use to the test runner var containingType = element.GetContainingType(); if (containingType == null) return false; // According to msdn, parameters to the constructor are positional parameters, and any // public read-write fields are named parameters. The name of the property we're after // is not a public field/property, so it's a positional parameter var propertyNames = from method in containingType.Methods from attributeInstance in method.GetAttributeInstances(PropertyDataAttributeName, false) select attributeInstance.PositionParameter(0).ConstantValue.Value as string; return propertyNames.Any(name => name == element.ShortName); } return false; }
private bool NeedCallStaticCtor(ITypeMember member) { if (member == null) { return(false); } if (ReferenceEquals(member.DeclaringType, _declType)) { return(false); } var method = member as IMethod; if (method != null) { return(method.IsConstructor || method.IsStatic); } var f = member as IField; if (f != null) { return(f.IsStatic); } return(false); }
public override string ProduceNativeCallConversionCode(string expr, ITypeMember m) { switch (m.PassedByType) { case PassedByType.Reference: //Could be called from NativeClass producer case PassedByType.Value: return(expr); case PassedByType.Pointer: if (IsVoid) { return(expr); } if (m.HasAttribute <ArrayTypeAttribute>()) { int len = m.GetAttribute <ArrayTypeAttribute>().Length; return("GetValueArrayFromNativeArray<" + FullyQualifiedCLRName + ", " + FullyQualifiedNativeName + ">( " + expr + " , " + len + " )"); } return(expr); default: throw new Exception("Unexpected"); } }
private static string FormatMessage(ITypeMember typeMember) { return(string.Format( Message, AccessibilityUtility.FormatAccessibilityDomainType(typeMember.AccessibilityDomain.DomainType), typeMember is ITypeElement ? "type" : "type member")); }
private void Register(ITypeMember member) { if (member is IMethod) { Register((IMethod)member); } }
private static bool IsTheoryPropertyDataProperty(ITypeMember element) { if (element.IsStatic && element.GetAccessRights() == AccessRights.PUBLIC) { // Make sure there is a containing type. The only example I've seen where this is null // is when the C# class is included in the project, but not compiled (i.e. build action // is set to None). Not sure if this is a bug or not - on the one hand, it's not compiled // so there isn't really a type there, on the other, there's enough info for it to be // a method, and that method has to live somewhere. Either way, we don't care. If it's // not compiled, it's no use to the test runner var containingType = element.GetContainingType(); if (containingType == null) { return(false); } // According to msdn, parameters to the constructor are positional parameters, and any // public read-write fields are named parameters. The name of the property we're after // is not a public field/property, so it's a positional parameter var propertyNames = from method in containingType.Methods from attributeInstance in method.GetAttributeInstances(PropertyDataAttributeName, false) select attributeInstance.PositionParameter(0).ConstantValue.Value as string; return(propertyNames.Any(name => name == element.ShortName)); } return(false); }
private static LLVMAbi PickLLVMAbi(ITypeMember Member, LLVMAssembly DeclaringAssembly) { var abiName = LLVMAttributes.GetAbiName(Member); if (abiName != null) { switch (abiName.ToLowerInvariant()) { case "c": return(DeclaringAssembly.ExternalAbi); case "c++": case "c#": return(DeclaringAssembly.Abi); default: throw new InvalidDataException( LLVMAttributes.AbiAttributeName + " specified unknown ABI '" + abiName + "'"); } } else if (Member.IsStatic && IsImportedMember(Member)) { return(DeclaringAssembly.ExternalAbi); } else { return(DeclaringAssembly.Abi); } }
private static bool ShouldProcessTypeMember(ITypeMember typeMember) { // Note that UnityEditor has a lot of InternalsVisibleTo, including for Unity.Collections and Unity.Entities // so make sure these projects are not part of the solution used to run this action! if (!typeMember.CanBeVisibleToSolution() || typeMember is IConstructor || typeMember is IAccessor) { return(false); } // Ignore Unity.Mathematics swizzling operators (all combinations of x,y,z and w) if (IsSwizzlingProperty(typeMember)) { return(false); } if (typeMember.GetContainingType() is IEnum enumTypeElement) { if (typeMember.ShortName == "iPhoneAndiPad" || typeMember.ShortName == "SetiPhoneLaunchScreenType") { return(false); // "andi", "seti" } // Don't do anything with the AdvertisingNetwork enum. It's full of weird names that would be nice to // not show typos for in comments (e.g. AerServ), but we have to split that into words, so we get "aer" // and "serv" as words in the dictionary, which are not useful // Same goes for Stores if (enumTypeElement.GetClrName().FullName == "UnityEngine.Analytics.AdvertisingNetwork" || enumTypeElement.GetClrName().FullName == "UnityEngine.Monetization.Store") { return(false); } } return(true); }
/// <summary> /// Here you can customize what to export when base class is class but exporting as interface /// </summary> /// <param name="sw">Output writer</param> /// <param name="element">Type itself</param> /// <param name="resolver">Type resolver</param> /// <param name="swtch">Pass here type attribute inherited from IAutoexportSwitchAttribute</param> protected virtual void HandleBaseClassExportingAsInterface(ITypeMember sw, Type element, TypeResolver resolver, IAutoexportSwitchAttribute swtch) { if (element._BaseType() != null) { var baseBp = Context.Project.Blueprint(element._BaseType()); var bp = Context.Project.Blueprint(element); if (baseBp.IsExportingAsInterface() && !bp.IsExportingAsInterface()) { // well.. bad but often case. // Here we should export members also for base class // we do not export methods - just properties and fields // but still. It is better thatn nothing if (sw.Documentation == null) { sw.Documentation = new RtJsdocNode(); } sw.Documentation.TagToDescription.Add(new Tuple <DocTag, string>(DocTag.Todo, string.Format("Automatically implemented from {0}", resolver.ResolveTypeName(element._BaseType())))); var baseBlueprint = Context.Project.Blueprint(element._BaseType()); var basExSwtch = baseBlueprint.Attr <TsInterfaceAttribute>(); Context.SpecialCase = true; ExportFields(sw, element._BaseType(), resolver, basExSwtch); ExportProperties(sw, element._BaseType(), resolver, basExSwtch); ExportMethods(sw, element._BaseType(), resolver, basExSwtch); Context.SpecialCase = false; Context.Warnings.Add(ErrorMessages.RTW0005_BaseClassExportingAsInterface.Warn(element._BaseType().FullName, element.FullName)); } } }
public void Add(ITypeMember member) { if (member == null) { throw new ArgumentNullException("member"); } //TODO: avoid duplicates switch (member.MemberType) { case MemberType.Field: _fields.Add((IField)member); break; case MemberType.Method: case MemberType.Constructor: _methods.Add((IMethod)member); break; case MemberType.Property: _properties.Add((IProperty)member); break; case MemberType.Event: _events.Add((IEvent)member); break; } }
public IncorrectBindingFlagsError(IMethod method, IInvocationExpression invocation, IExpression bindingFlagsExpression, BindingFlags expectedBindingflags, ITypeMember member) { _method = method; _invocation = invocation; _bindingFlagsExpression = bindingFlagsExpression; _expectedBindingflags = expectedBindingflags; _member = member; }
/// <summary> /// Initializes a new instance of the <see cref="VirtualTreeGridItem"/> class. /// </summary> /// <param name="category">The category.</param> /// <param name="parent">The parent.</param> /// <param name="data">The data.</param> /// <param name="kind">The kind.</param> public VirtualTreeGridItem(VirtualTreeGridCategory category, IHasChildren parent, ITypeMember data, ModelKind kind) { this.category = category; DataItem = data; this.parent = parent; this.kind = kind; }
private void HandleGenericTaskTypes(IHighlightingConsumer consumer, ITypeMember @delegate, IUserTypeUsage typeUsageOfTask) { var typeIdentifier = typeUsageOfTask.ScalarTypeName.NameIdentifier; var innerTypeUsage = typeUsageOfTask.ScalarTypeName.TypeArgumentList.TypeArgumentNodes.FirstOrDefault(); HandleElement(consumer, @delegate, typeIdentifier); HandleContainerElement(consumer, @delegate, innerTypeUsage); }
/// <summary> /// Commits the specified data. /// </summary> /// <param name="data">The data.</param> public void Commit(ITypeMember data) { if (IsNewValue) { parent.GetChildrenForCategory(category).Add(data); DataItem = data; } }
public DefParam(ITypeMember m, string name) { this._name = name; this._type = m.Type; this._typename = m.TypeName; this.PassedByType = m.PassedByType; this._isConst = m.IsConst; }
public void SetIndex(ITypeMember member, TaskContext context) { member.Dispatcher.Invoke(() => { var index = RandomUtility.Next(member.Template.Count); member.SetIndex(context.Authentication, index); }); }
public void SetName(ITypeMember member, TaskContext context) { member.Dispatcher.Invoke(() => { var memberName = RandomUtility.NextIdentifier(); member.SetName(context.Authentication, memberName); }); }
public void SetComment(ITypeMember member, TaskContext context) { member.Dispatcher.Invoke(() => { var comment = RandomUtility.NextString(); member.SetComment(context.Authentication, comment); }); }
/// <summary> /// Checks if the given property is a Nuke build parameter definition. /// </summary> /// <param name="typeMember">The type member to test.</param> /// <returns>True if the type member is a Nuke build parameter definition.</returns> public static bool IsNukeBuildParameter(this ITypeMember typeMember) { if (!(typeMember is IProperty property)) { return(false); } return(property.IsNukeBuildParameter()); }
public ParamDefinition(MetaDefinition metaDef, ITypeMember m, string name) : base(metaDef) { _name = name; _type = m.MemberType; _typename = m.MemberTypeName; PassedByType = m.PassedByType; _isConst = m.IsConst; }
protected override int CompareTypeMember(ITypeMember x, ITypeMember y) { DeclaredElementType xType = x.GetElementType(); DeclaredElementType yType = y.GetElementType(); if (xType.Equals(yType)) return base.CompareTypeMember(x, y); return StringComparer.InvariantCultureIgnoreCase.Compare(xType.PresentableName, yType.PresentableName); }
/// <summary> /// Exports all type members sequentially /// </summary> /// <param name="element">Type itself</param> /// <param name="resolver">Type resolver</param> /// <param name="typeMember">Placeholder for members</param> /// <param name="swtch">Pass here type attribute inherited from IAutoexportSwitchAttribute</param> protected virtual void ExportMembers(Type element, TypeResolver resolver, ITypeMember typeMember, IAutoexportSwitchAttribute swtch) { ExportConstructors(typeMember, element, resolver, swtch); ExportFields(typeMember, element, resolver, swtch); ExportProperties(typeMember, element, resolver, swtch); ExportMethods(typeMember, element, resolver, swtch); HandleBaseClassExportingAsInterface(typeMember, element, resolver, swtch); }
static void WriteAttrib(XmlWriter writer, ITypeMember m) { string s = ApiInfoExtensions.GetAttrib(m); if (string.IsNullOrEmpty(s)) { return; } writer.WriteAttributeString("attrib", s); }
public static string GetFullName(this ITypeMember member) { var type = member.DeclaringType; if (type == null) { throw new ArgumentException("Member has no declaring type."); } return(type.FullName + "." + member.Name); }
public static bool IsColorProperty(ITypeMember typeMember) { if (typeMember is IProperty && typeMember.IsStatic) { var unityColorTypes = GetInstance(typeMember.Module); return unityColorTypes.IsUnityColorTypeSupportingProperties(typeMember.GetContainingType()) && UnityNamedColors.Get(typeMember.ShortName).HasValue; } return false; }
public static void InsertAfterInitialFields(this IClass cl, ITypeMember member) { IField lastField = null; foreach (var m in cl.Members) { if (m is IField) { lastField = m as IField; } else { break; } } if (lastField == null) cl.MembersAll.InsertOrMove(0, member); else { cl.MembersAll.InsertOrMoveAfter(lastField, member); } }
private static bool IsTheoryPropertyDataProperty(ITypeMember element) { if (element.IsStatic && element.GetAccessRights() == AccessRights.PUBLIC) { // According to msdn, parameters to the constructor are positional parameters, and any // public read-write fields are named parameters. The name of the property we're after // is not a public field/property, so it's a positional parameter var propertyNames = from method in element.GetContainingType().Methods from attributeInstance in method.GetAttributeInstances(PropertyDataAttributeName, false) select attributeInstance.PositionParameter(0).ConstantValue.Value as string; return propertyNames.Any(name => name == element.ShortName); } return false; }
public void AddAssignmentToBody(IConstructorDeclaration constructorDeclaration, IStatement anchorStatement, bool insertBefore, IParameter parameter, ITypeMember member) { var constructorDeclaration1 = constructorDeclaration; var instance = CSharpElementFactory.GetInstance(constructorDeclaration1); if (constructorDeclaration1.Body == null) constructorDeclaration1.SetBody(instance.CreateEmptyBlock()); var shortName1 = parameter.ShortName; var shortName2 = member.ShortName; var statement = instance.CreateStatement("$0 = $1;", (object) shortName2, (object) shortName1); CodeStyleUtil.ApplyRecursive<ThisQualifierStyleSuggestion>(insertBefore ? constructorDeclaration1.Body.AddStatementBefore(statement, (ICSharpStatement) anchorStatement) : constructorDeclaration1.Body.AddStatementAfter(statement, (ICSharpStatement) anchorStatement)); }
protected virtual bool IsUnhandledType(ITypeMember m) { if (m.Type.IsIgnored) return true; if (m.Type is DefClass && (m.Type as DefClass).IsSingleton) return true; switch (m.TypeName) { case "UserDefinedObject": return true; default: return false; } }
protected virtual bool? CheckTypeMemberForGetProperty(ITypeMember m) { if (!m.Type.IsValueType && (m.Type.IsSharedPtr || m.Type is DefTemplateOneType || m.Type is DefTemplateTwoTypes)) return false; if (m.Type.HasAttribute<ReturnOnlyByMethodAttribute>()) return false; return null; }
protected virtual string GetCLRTypeName(ITypeMember m) { CheckTypeForDependancy(m.Type); return m.CLRTypeName; }
protected virtual string GetCLRTypeName(ITypeMember m) { AddTypeDependancy(m.Type); if (m.Type.IsUnnamedSTLContainer) return GetClassName() + "::" + m.CLRTypeName; else return m.CLRTypeName; }
public override string GetCLRTypeName(ITypeMember m) { switch (m.PassedByType) { case PassedByType.Reference: case PassedByType.Value: return FullCLRName + "^"; case PassedByType.PointerPointer: case PassedByType.Pointer: default: throw new Exception("Unexpected"); } }
///<summary> /// /// Check if the given type member is visible in this language /// ///</summary> /// ///<returns> /// ///</returns> /// public override bool IsTypeMemberVisible(ITypeMember member) { return base.IsTypeMemberVisible(member); }
public override string GetNativeCallConversion(string expr, ITypeMember m) { switch (m.PassedByType) { case PassedByType.Reference: case PassedByType.Value: return "ToManaged<" + ConversionTypeName + ", " + FullNativeName + ">( " + expr + " )"; case PassedByType.PointerPointer: case PassedByType.Pointer: default: throw new Exception("Unexpected"); } }
public override string GetCLRTypeName(ITypeMember m) { switch (m.PassedByType) { case PassedByType.Value: return Name; case PassedByType.Pointer: if (IsVoid) { return "void*"; } else if (m.HasAttribute<ArrayTypeAttribute>()) { return "array<" + FullCLRName + ">^"; } else { string name = Name + "*"; if (m.IsConst) name = "const " + name; return name; } case PassedByType.Reference: case PassedByType.PointerPointer: default: throw new Exception("Unexpected"); } }
public override string GetCLRTypeName(ITypeMember m) { switch (m.PassedByType) { case PassedByType.Reference: case PassedByType.Pointer: if (m.IsConst) return FullCLRName.Replace(CLRName, "Const_" + CLRName) + "^"; else return FullCLRName + "^"; case PassedByType.Value: if (m.IsConst || this.IsReadOnly) return FullCLRName.Replace(CLRName, "Const_" + CLRName) + "^"; else return FullCLRName + "^"; case PassedByType.PointerPointer: default: throw new Exception("Unexpected"); } }
public override string GetNativeCallConversion(string expr, ITypeMember m) { switch (m.PassedByType) { case PassedByType.Reference: //Could be called from NativeClass producer case PassedByType.Value: return expr; case PassedByType.Pointer: if (IsVoid) { return expr; } else if (m.HasAttribute<ArrayTypeAttribute>()) { int len = m.GetAttribute<ArrayTypeAttribute>().Length; return "GetValueArrayFromNativeArray<" + FullCLRName + ", " + FullNativeName + ">( " + expr + " , " + len + " )"; } else return expr; case PassedByType.PointerPointer: default: throw new Exception("Unexpected"); } }
public override string GetNativeCallConversion(string expr, ITypeMember m) { switch (m.PassedByType) { case PassedByType.Reference: case PassedByType.Value: return expr; case PassedByType.PointerPointer: case PassedByType.Pointer: default: throw new Exception("Unexpected"); } }
private ConstantValue2 GetAttributeNamedParameterHack(IAttributeInstance attributeInstance, ITypeMember typeMember) { IAttribute attribute = GetCSharpAttributeHack(attributeInstance); if (attribute != null) { foreach (IPropertyAssignmentNode propertyAssignmentNode in attribute.ToTreeNode().PropertyAssignments) { IPropertyAssignment propertyAssignment = propertyAssignmentNode; if (propertyAssignment.Reference.Resolve().DeclaredElement == typeMember) { IType propertyType = ((ITypeOwner)typeMember).Type; ICSharpExpression expression = propertyAssignment.Source; return GetCSharpConstantValueHack(expression, propertyType); } } return ConstantValue2.BAD_VALUE; } return attributeInstance.NamedParameter(typeMember); }
private ConstantValue? GetAttributeNamedParameter(IAttributeInstance attributeHandle, ITypeMember memberHandle) { #if RESHARPER_31 ConstantValue2 rawValue = GetAttributeNamedParameterHack(attributeHandle, memberHandle); return rawValue.IsBadValue() ? (ConstantValue?)null : ConvertConstantValue(rawValue.Value); #else AttributeValue rawValue = attributeHandle.NamedParameter(memberHandle); return rawValue.IsBadValue ? (ConstantValue?) null : ConvertConstantValue(rawValue); #endif }
public override string GetNativeCallConversion(string expr, ITypeMember m) { switch (m.PassedByType) { case PassedByType.Reference: case PassedByType.Pointer: return expr; case PassedByType.Value: if (m.IsConst || this.IsReadOnly) return FullCLRName + "::ByValue( " + expr + " )->ReadOnlyInstance"; else return FullCLRName + "::ByValue( " + expr + " )"; case PassedByType.PointerPointer: default: throw new Exception("Unexpected"); } }