private void ImportMemberDetails(MemberSymbol memberSymbol, MethodDefinition methodDefinition, ICustomAttributeProvider attributeProvider) { if (methodDefinition != null) { MemberVisibility visibility = MemberVisibility.PrivateInstance; if (methodDefinition.IsStatic) { visibility |= MemberVisibility.Static; } if (methodDefinition.IsPublic) { visibility |= MemberVisibility.Public; } else if (methodDefinition.IsFamily || methodDefinition.IsFamilyOrAssembly) { visibility |= MemberVisibility.Protected; } memberSymbol.SetVisibility(visibility); } memberSymbol.SetNameCasing(MetadataHelpers.ShouldPreserveCase(attributeProvider)); string scriptName = MetadataHelpers.GetScriptName(attributeProvider); if (scriptName != null) { memberSymbol.SetTransformedName(scriptName); } }
/// <summary> /// Creates a MethodSpecifier. /// </summary> /// <param name="name">Name of the method without any prefixes.</param> /// <param name="arguments">Specifiers for the arguments of the method.</param> /// <param name="returnTypes">Specifiers for the return types of the method.</param> /// <param name="modifiers">Modifiers of the method.</param> /// <param name="declaringType">Specifier for the type this method is contained in.</param> /// <param name="genericArguments">Generic arguments this method takes.</param> public MethodSpecifier ( string name, IEnumerable <MethodParameter> arguments, IEnumerable <BaseType> returnTypes, MethodModifiers modifiers, MemberVisibility visibility, TypeSpecifier declaringType, IEnumerable <BaseType> genericArguments ) { this.Name = name; this.DeclaringType = declaringType; this.Parameters = arguments.ToList(); this.ReturnTypes = returnTypes.ToList(); this.Modifiers = modifiers; this.Visibility = visibility; this.GenericArguments = genericArguments.ToList(); this.HashCodeCache = HashCode.Combine ( this.Name, this.Modifiers, string.Join(",", this.GenericArguments), string.Join(",", this.ReturnTypes), string.Join(",", this.Parameters), this.Visibility, this.DeclaringType ); }
/// <summary> /// Adds the given mixin to the given target type with a number of explicit dependencies and suppressed mixins. This is a shortcut /// method for calling <see cref="ForClass"/>, <see cref="ClassContextBuilder.AddMixin(System.Type,Remotion.Mixins.Context.MixinContextOrigin)"/>, /// <see cref="MixinContextBuilder.WithDependencies"/>, and <see cref="MixinContextBuilder.ReplaceMixins"/> in a row. /// </summary> /// <param name="mixinKind">The kind of relationship the mixin has with its target class.</param> /// <param name="targetType">The target type to add a mixin for.</param> /// <param name="mixinType">The mixin type to add.</param> /// <param name="introducedMemberVisibility">The default visibility to be used for introduced members.</param> /// <param name="explicitDependencies">The explicit dependencies of the mixin in the context of the target type.</param> /// <param name="suppressedMixins">The mixins suppressed by this mixin in the context of the target type.</param> /// <param name="origin">A <see cref="MixinContextOrigin"/> object describing where the mixin configuration originates from.</param> public virtual MixinConfigurationBuilder AddMixinToClass( MixinKind mixinKind, Type targetType, Type mixinType, MemberVisibility introducedMemberVisibility, IEnumerable <Type> explicitDependencies, IEnumerable <Type> suppressedMixins, MixinContextOrigin origin) { ArgumentUtility.CheckNotNull("targetType", targetType); ArgumentUtility.CheckNotNull("mixinType", mixinType); ArgumentUtility.CheckNotNull("explicitDependencies", explicitDependencies); ArgumentUtility.CheckNotNull("suppressedMixins", suppressedMixins); ArgumentUtility.CheckNotNull("origin", origin); MixinContextBuilder mixinContextBuilder = AddMixinToClass(targetType, mixinType, origin); mixinContextBuilder .OfKind(mixinKind) .WithDependencies(explicitDependencies.ToArray()) .WithIntroducedMemberVisibility(introducedMemberVisibility) .ReplaceMixins(suppressedMixins.ToArray()); return(this); }
private void ImportMemberDetails(MemberSymbol memberSymbol, MethodDefinition methodDefinition, ICustomAttributeProvider attributeProvider) { if (methodDefinition != null) { MemberVisibility visibility = MemberVisibility.PrivateInstance; if (methodDefinition.IsStatic) { visibility |= MemberVisibility.Static; } if (methodDefinition.IsPublic) { visibility |= MemberVisibility.Public; } else if (methodDefinition.IsFamily || methodDefinition.IsFamilyOrAssembly) { visibility |= MemberVisibility.Protected; } memberSymbol.SetVisibility(visibility); } string scriptName = MetadataHelpers.GetScriptName(attributeProvider, out bool _, out bool preserveCase); memberSymbol.SetNameCasing(preserveCase); if (scriptName != null) { memberSymbol.SetTransformedName(scriptName); } // PreserveName is ignored - it only is used for internal members, which are not imported. }
/// <summary> /// Initializes the preset with the specified visiblity. The preset must be initialized before the preset values are applied so the delegates can be created. /// </summary> /// <param name="obj">The object to map the delegates to.</param> /// <param name="visibility">Specifies the visibility of the field/properties that should be retrieved.</param> public virtual void Initialize(object obj, MemberVisibility visibility) { var properties = Serialization.GetSerializedProperties(obj.GetType(), visibility); var valueCount = 0; m_Delegates = new BaseDelegate[properties.Length]; for (int i = 0; i < properties.Length; ++i) { // The property may not be valid. if (Serialization.GetValidGetMethod(properties[i], visibility) == null) { continue; } // Create a generic delegate based on the property type. var genericDelegateType = typeof(GenericDelegate <>).MakeGenericType(properties[i].PropertyType); m_Delegates[valueCount] = Activator.CreateInstance(genericDelegateType) as BaseDelegate; // Initialize the delegate. if (m_Delegates[valueCount] != null) { m_Delegates[valueCount].Initialize(obj, properties[i], visibility); } else { Debug.LogWarning("Warning: Unable to create preset of type " + properties[i].PropertyType); } valueCount++; } if (m_Delegates.Length != valueCount) { Array.Resize(ref m_Delegates, valueCount); } }
//----------------------------------------------------------------------------------------------------------------------------------------------------- protected AbstractMember(MemberVisibility visibility, MemberModifier modifier, string name) : this() { this.Visibility = visibility; this.Modifier = modifier; this.Name = name; }
private MemberVisibility GetVisibility(MemberNode node, TypeSymbol typeSymbol) { if (typeSymbol.Type == SymbolType.Interface) { return(MemberVisibility.Public); } MemberVisibility visibility = MemberVisibility.PrivateInstance; if (((node.Modifiers & Modifiers.Static) != 0) || (node.NodeType == ParseNodeType.ConstFieldDeclaration)) { visibility |= MemberVisibility.Static; } if ((node.Modifiers & Modifiers.Public) != 0) { visibility |= MemberVisibility.Public; } else { if ((node.Modifiers & Modifiers.Protected) != 0) { visibility |= MemberVisibility.Protected; } if ((node.Modifiers & Modifiers.Internal) != 0) { visibility |= MemberVisibility.Internal; } } return(visibility); }
//----------------------------------------------------------------------------------------------------------------------------------------------------- public TypeMember(MemberVisibility visibility, TypeMemberKind typeKind, string name, params TypeMember[] genericArguments) : this() { this.Visibility = visibility; this.TypeKind = typeKind; this.Name = name; if (genericArguments != null) { this.IsGenericType = (genericArguments.Length > 0); if (this.IsGenericType) { this.IsGenericTypeDefinition = genericArguments.Any(arg => arg.TypeKind == TypeMemberKind.GenericParameter); if (this.IsGenericTypeDefinition) { this.GenericTypeParameters.AddRange(genericArguments); } else { this.GenericTypeArguments.AddRange(genericArguments); } } } }
public void CanEmitConstructorDeclaration( string expectedCode, MemberVisibility visibility, MemberModifier modifier, Delegate signaturePrototype, Action <ConstructorMember> constructorSetup) { //-- arrange var constructor = new ConstructorMember(visibility, modifier, "ClassOne", new MethodSignature(signaturePrototype.GetMethodInfo())); if (constructorSetup != null) { constructorSetup(constructor); } var enclosingClassMember = new TypeMember(MemberVisibility.Public, TypeMemberKind.Class, "ClassOne"); enclosingClassMember.Members.Add(constructor); var enclosingClassEmitter = new ClassSyntaxEmitter(enclosingClassMember); var expectedClassCode = "public class ClassOne { " + expectedCode + " }"; //-- act var actualClassSyntax = enclosingClassEmitter.EmitSyntax(); //-- assert actualClassSyntax.Should().BeEquivalentToCode(expectedClassCode); }
public ClassImporter(string xamlFileName, string localAssemblyName, string rootNamespace) { this.xamlFileName = xamlFileName; this.localAssemblyName = localAssemblyName; this.rootNamespace = rootNamespace; this.DefaultClassIsPublic = true; this.DefaultFieldVisibility = MemberVisibility.Assembly; this.namespaceTable = new NamespaceTable(localAssemblyName); }
public InterfaceIntroductionDefinitionBuilder(MixinDefinition mixin, MemberVisibility defaultVisibility) { _mixin = mixin; _defaultVisibility = defaultVisibility; _nonIntroducedInterfaces = new HashSet <Type> { typeof(ISerializable), typeof(IDeserializationCallback), typeof(IInitializableMixin) }; AnalyzeNonIntroducedInterfaces(); }
public ClassImporter(string xamlFileName, string localAssemblyName, string rootNamespace) { this.xamlFileName = xamlFileName; this.localAssemblyName = localAssemblyName; this.rootNamespace = rootNamespace; this.DefaultClassIsPublic = true; this.DefaultFieldVisibility = MemberVisibility.Assembly; this.namespaceTable = new NamespaceTable(localAssemblyName); }
private void ImportFields(TypeSymbol typeSymbol) { TypeDefinition type = (TypeDefinition)typeSymbol.MetadataReference; foreach (FieldDefinition field in type.Fields) { if (field.IsSpecialName) { continue; } if (field.IsPrivate || field.IsAssembly || field.IsFamilyAndAssembly) { continue; } string fieldName = field.Name; TypeSymbol fieldType = ResolveType(field.FieldType); if (fieldType == null) { continue; } MemberVisibility visibility = MemberVisibility.PrivateInstance; if (field.IsStatic) { visibility |= MemberVisibility.Static; } if (field.IsPublic) { visibility |= MemberVisibility.Public; } else if (field.IsFamily || field.IsFamilyOrAssembly) { visibility |= MemberVisibility.Protected; } FieldSymbol fieldSymbol = new FieldSymbol(fieldName, typeSymbol, fieldType); fieldSymbol.SetVisibility(visibility); ImportMemberDetails(fieldSymbol, null, field); if (field.IsLiteral && field.HasConstant && !typeSymbol.IsCoreType && (field.FieldType.IsPrimitive || field.FieldType.Name == "String")) { fieldSymbol.SetConstant(); fieldSymbol.Value = field.Constant; } typeSymbol.AddMember(fieldSymbol); } }
/// <summary> /// Initializes the preset with the specified visiblity. The preset must be initialized before the preset values are applied so the delegates can be created. /// </summary> /// <param name="obj">The object to map the delegates to.</param> /// <param name="visibility">Specifies the visibility of the field/properties that should be retrieved.</param> public override void Initialize(object obj, MemberVisibility visibility) { base.Initialize(obj, visibility); m_DelegateIndexMap = new Dictionary <MethodInfo, int>(); for (int i = 0; i < m_Delegates.Length; ++i) { m_DelegateIndexMap.Add(m_Delegates[i].SetMethod, i); } }
private readonly List<AssemblyName> _referencedAssemblies; // = new List<AssemblyName>(); #endregion Fields #region Constructors /// <summary> /// Initializes a new instance of the <see cref="T:AssemblyFetcher"/> class. /// </summary> /// <param name="methodVisibility">The method visibility to parse.</param> /// <param name="assemblyName">Description text of the root assembly node.</param> /// <param name="inputAssemblies">The list of input assemblies.</param> public AssemblyFetcher(MemberVisibility methodVisibility, string assemblyName, IEnumerable<string> inputAssemblies) { Guard.NotNullOrEmpty(() => assemblyName, assemblyName); Guard.NotNull(() => inputAssemblies, inputAssemblies); _assemblyGraphTreeView = new TestNode() { Text = assemblyName }; _inputAssemblyOpenFileDialog = inputAssemblies.ToList(); _referencedAssemblies = new List<AssemblyName>(); this.methodVisibility = methodVisibility; }
public VariableSpecifier(string name, TypeSpecifier type, MemberVisibility getterVisibility, MemberVisibility setterVisibility, TypeSpecifier declaringType, VariableModifiers modifiers) { Name = name; Type = type; GetterVisibility = getterVisibility; SetterVisibility = setterVisibility; DeclaringType = declaringType; Modifiers = modifiers; }
/// <summary> /// Creates a persistable preset based off of the specified component and visibility. /// </summary> /// <param name="obj">The object to retrieve the property values of.</param> /// <param name="visibility">Specifies the visibility of the field/properties that should be retrieved.</param> /// <returns>The created preset. Null if no properties have been found to create the preset with.</returns> public static PersistablePreset CreatePreset(object obj, MemberVisibility visibility) { var data = new Serialization(); data.Serialize(obj, false, visibility); var preset = CreateInstance <PersistablePreset>(); preset.Data = data; return(preset); }
public ConstructorMember( MemberVisibility visibility, MemberModifier modifier, string name, MethodSignature signature) { this.Visibility = visibility; this.Modifier = modifier; this.Name = name; this.Signature = signature; }
//----------------------------------------------------------------------------------------------------------------------------------------------------- public TypeMember( TypeGeneratorInfo generator, string namespaceName, MemberVisibility visibility, TypeMemberKind typeKind, string name, params TypeMember[] genericTypeArguments) : this(namespaceName, visibility, typeKind, name, genericTypeArguments) { this.Generator = generator; }
protected MemberIntroductionDefinitionBase( InterfaceIntroductionDefinition declaringInterface, TMemberInfo interfaceMember, TMemberDefinition implementingMember, MemberVisibility visibility) { ArgumentUtility.CheckNotNull("interfaceMember", interfaceMember); ArgumentUtility.CheckNotNull("declaringInterface", declaringInterface); ArgumentUtility.CheckNotNull("implementingMember", implementingMember); _declaringInterface = declaringInterface; _implementingMember = implementingMember; _interfaceMember = interfaceMember; _visibility = visibility; }
public static string ToCSharp(this MemberVisibility value, MemberVisibility defaultValue) { if(value == defaultValue) return ""; switch(value) { case MemberVisibility.Internal: return "internal "; case MemberVisibility.Private: return "private "; case MemberVisibility.Protected: return "protected "; case MemberVisibility.ProtectedInternal: return "protected internal "; case MemberVisibility.Public: return "public "; default: throw new InvalidOperationException(); } }
/// <summary> /// Initialize the delegate. /// </summary> /// <param name="obj">The object which the delegate operates on.</param> /// <param name="property">The property that the delegate will invoke.</param> /// <param name="visibility">Specifies the visibility of the field/properties that should be retrieved.</param> public override void Initialize(object obj, PropertyInfo property, MemberVisibility visibility) { m_SetMethod = property.GetSetMethod(visibility != MemberVisibility.Public); if (m_SetMethod != null) { m_Setter = (Action <T>)Delegate.CreateDelegate(typeof(Action <T>), obj, m_SetMethod); } var getMethod = property.GetGetMethod(visibility != MemberVisibility.Public); if (getMethod != null) { m_Getter = (Func <T>)Delegate.CreateDelegate(typeof(Func <T>), obj, getMethod); // Create an instance of the value if it is an array or a list. This will allow a snapshot of the array/list elements to be saved without having the // array/list change because it is later modified by reference. var type = typeof(T); m_IsIList = typeof(IList).IsAssignableFrom(type); if (m_IsIList) { if (typeof(T).IsArray) { var value = m_Getter() as Array; #if NET_4_6 || UNITY_2018_3_OR_NEWER || UNITY_WEBGL || UNITY_IOS || UNITY_ANDROID || UNITY_WII || UNITY_WIIU || UNITY_SWITCH || UNITY_PS3 || UNITY_PS4 || UNITY_XBOXONE || UNITY_WSA m_Value = (T)(object)Array.CreateInstance(type.GetElementType(), value == null ? 0 : value.Length); #else m_Value = Array.CreateInstance(type.GetElementType(), value == null ? 0 : value.Length) as T; #endif } else { var baseType = type; while (!baseType.IsGenericType) { baseType = baseType.BaseType; } var elementType = baseType.GetGenericArguments()[0]; if (type.IsGenericType) { m_Value = (T)Activator.CreateInstance(typeof(List <>).MakeGenericType(elementType)); } else { m_Value = (T)Activator.CreateInstance(type); } } } // The value should be set at the same time the delegate is initailized. UpdateValue(); } }
/// <summary> /// Initializes a new instance of the <see cref="T:AssemblyFetcher"/> class. /// </summary> /// <param name="methodVisibility">The method visibility to parse.</param> /// <param name="assemblyName">Description text of the root assembly node.</param> /// <param name="inputAssemblies">The list of input assemblies.</param> public AssemblyFetcher(MemberVisibility methodVisibility, string assemblyName, IEnumerable <string> inputAssemblies) { Guard.NotNullOrEmpty(() => assemblyName, assemblyName); Guard.NotNull(() => inputAssemblies, inputAssemblies); _assemblyGraphTreeView = new TestNode() { Text = assemblyName }; _inputAssemblyOpenFileDialog = inputAssemblies.ToList(); _referencedAssemblies = new List <AssemblyName>(); this.methodVisibility = methodVisibility; }
/// <summary> /// Initializes the available property array. /// </summary> private void OnEnable() { // If the preset is a child of a StateConfiguration asset then the AllPublic MemberVisiblity type should be shown. if (!AssetDatabase.IsMainAsset(target)) { var mainAsset = AssetDatabase.LoadAssetAtPath(AssetDatabase.GetAssetPath(target), TypeUtility.GetType("Opsive.UltimateCharacterController.StateSystem.StateConfiguration")); if (mainAsset != null) { m_Visiblity = MemberVisibility.AllPublic; } } InitializeAvailablePropertyArray(); }
/// <summary> /// Initializes the available property array. /// </summary> private void OnEnable() { // If the preset is a child of a StateConfiguration asset then the AllPublic MemberVisiblity type should be shown. if (!AssetDatabase.IsMainAsset(target)) { var mainAsset = AssetDatabase.LoadAssetAtPath(AssetDatabase.GetAssetPath(target), typeof(StateConfiguration)) as StateConfiguration; if (mainAsset != null) { m_Visiblity = MemberVisibility.AllPublic; } } InitializeAvailablePropertyArray(); }
public static MixinContext Create( MixinKind mixinKind = MixinKind.Extending, Type mixinType = null, MemberVisibility introducedMemberVisibility = MemberVisibility.Private, IEnumerable <Type> explicitDependencies = null, MixinContextOrigin origin = null) { return(new MixinContext( mixinKind, mixinType ?? typeof(UnspecifiedType), introducedMemberVisibility, explicitDependencies ?? new[] { typeof(object), typeof(string) }, origin ?? MixinContextOriginObjectMother.Create())); }
public void SetUp() { var assemblies = new[] { typeof(AssemblyFetcher).Assembly, typeof(AssemblyFetcherTest).Assembly, typeof(Rhino.Mocks.MockRepository).Assembly, }.ToList(); this.methodVisibility = MemberVisibility.Public; this.assemblyName = typeof(AssemblyFetcherTest).Assembly.Location; this.inputAssemblies = assemblies.Select(e => e.Location).ToList(); this.testObject = new AssemblyFetcher(this.methodVisibility, this.assemblyName, this.inputAssemblies); }
private void AnalyzeEvents(InterfaceIntroductionDefinition introducedInterface, MemberImplementationFinder memberFinder, HashSet <MethodInfo> specialMethods) { foreach (EventInfo interfaceEvent in introducedInterface.InterfaceType.GetEvents()) { EventDefinition implementer = memberFinder.FindEventImplementation(interfaceEvent); CheckMemberImplementationFound(implementer, interfaceEvent); MemberVisibility visibility = GetVisibility(implementer.MemberInfo); introducedInterface.IntroducedEvents.Add(new EventIntroductionDefinition(introducedInterface, interfaceEvent, implementer, visibility)); specialMethods.Add(interfaceEvent.GetAddMethod()); specialMethods.Add(interfaceEvent.GetRemoveMethod()); } }
private void AnalyzeMethods(InterfaceIntroductionDefinition introducedInterface, MemberImplementationFinder memberFinder, HashSet <MethodInfo> specialMethods) { foreach (MethodInfo interfaceMethod in introducedInterface.InterfaceType.GetMethods()) { if (!specialMethods.Contains(interfaceMethod)) { MethodDefinition implementer = memberFinder.FindMethodImplementation(interfaceMethod); CheckMemberImplementationFound(implementer, interfaceMethod); MemberVisibility visibility = GetVisibility(implementer.MemberInfo); introducedInterface.IntroducedMethods.Add(new MethodIntroductionDefinition(introducedInterface, interfaceMethod, implementer, visibility)); } } }
/// <summary> /// Returns whether a given visibility for a member of a type is visible from another type. /// </summary> /// <param name="fromType">Type that we are seeing from.</param> /// <param name="type">Type that we are looking at.</param> /// <param name="visibility">Visibility of the member on type.</param> /// <returns></returns> public static bool IsVisible(TypeSpecifier fromType, TypeSpecifier type, MemberVisibility visibility, Func <TypeSpecifier, TypeSpecifier, bool> isSubclassOf) { // TODO: Internal if (fromType == type) { return(true); } else if (isSubclassOf(fromType, type)) { return(visibility.HasFlag(MemberVisibility.ProtectedOrPublic)); } return(visibility.HasFlag(MemberVisibility.Public)); }
MemberAttributes GetMemberAttributes(MemberVisibility visibility) { switch (visibility) { case MemberVisibility.Private: return MemberAttributes.Private; case MemberVisibility.Public: return MemberAttributes.Public; case MemberVisibility.Family: return MemberAttributes.Family; case MemberVisibility.Assembly: return MemberAttributes.Assembly; case MemberVisibility.FamilyOrAssembly: return MemberAttributes.FamilyOrAssembly; case MemberVisibility.FamilyAndAssembly: return MemberAttributes.FamilyAndAssembly; default: throw Fx.AssertAndThrow("Invalid MemberVisibility value"); } }
public void SetUp() { var assemblies = new[] { typeof(AssemblyFetcher).Assembly, typeof(AssemblyFetcherTest).Assembly, typeof(Rhino.Mocks.MockRepository).Assembly, }.ToList(); this.methodVisibility = MemberVisibility.Public; this.assemblyName = typeof(AssemblyFetcherTest).Assembly.Location; this.inputAssemblies = assemblies.Select(e => e.Location).ToList(); this.testObject = new AssemblyFetcher(this.methodVisibility, this.assemblyName, this.inputAssemblies); }
public MethodSymbol(string name, TypeSymbol parent, TypeSymbol returnType, MemberVisibility visibility) : this(SymbolType.Method, name, parent, returnType) { SetVisibility(visibility); }
/// <summary> /// Creates a code generation expression for an object to test with a member field and initialization /// in the previous specified <see cref="SetUpMethod"/> method. /// </summary> /// <param name="visibility">The visibility level of the objects to parse. Default should be public.</param> /// <returns> /// The initialization expression of the object under test. /// </returns> public abstract CodeObjectCreateExpression BuildTestObject(MemberVisibility visibility);
public IndexerSymbol(TypeSymbol parent, TypeSymbol propertyType, MemberVisibility visibility) : this(parent, propertyType) { SetVisibility(visibility); }
public void SetVisibility(MemberVisibility visibility) { _visibility = visibility; }
private static bool TryGetMemberVisibility(IToken token, out MemberVisibility visibility) { if (token.EqualsStringInvariant(AnalyzerConstants.Visibility_Private)) { visibility = MemberVisibility.Private; return true; } if (token.EqualsStringInvariant(AnalyzerConstants.Visibility_Public)) { visibility = MemberVisibility.Public; return true; } visibility = MemberVisibility.Default; return false; }