Esempio n. 1
0
        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);
        }
Esempio n. 2
0
        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();
        }
Esempio n. 3
0
        public AbcTrait Find(ITypeMember member)
        {
            var      key = KeyOf(member);
            AbcTrait trait;

            return(_cache.TryGetValue(key, out trait) ? trait : null);
        }
Esempio n. 4
0
        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");
            }
        }
Esempio n. 5
0
        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;
                }
            }
        }
Esempio n. 6
0
        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;
                }
            }
        }
Esempio n. 7
0
        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");
            }
        }
Esempio n. 8
0
        //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;
        }
Esempio n. 10
0
        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);
        }
Esempio n. 11
0
        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");
            }
        }
Esempio n. 12
0
 private static string FormatMessage(ITypeMember typeMember)
 {
     return(string.Format(
                Message,
                AccessibilityUtility.FormatAccessibilityDomainType(typeMember.AccessibilityDomain.DomainType),
                typeMember is ITypeElement ? "type" : "type member"));
 }
Esempio n. 13
0
 private void Register(ITypeMember member)
 {
     if (member is IMethod)
     {
         Register((IMethod)member);
     }
 }
Esempio n. 14
0
        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);
        }
Esempio n. 15
0
        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);
        }
Esempio n. 17
0
        /// <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));
                }
            }
        }
Esempio n. 18
0
        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;
 }
Esempio n. 20
0
 /// <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);
        }
Esempio n. 22
0
 /// <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;
     }
 }
Esempio n. 23
0
 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;
 }
Esempio n. 24
0
 public void SetIndex(ITypeMember member, TaskContext context)
 {
     member.Dispatcher.Invoke(() =>
     {
         var index = RandomUtility.Next(member.Template.Count);
         member.SetIndex(context.Authentication, index);
     });
 }
Esempio n. 25
0
 public void SetName(ITypeMember member, TaskContext context)
 {
     member.Dispatcher.Invoke(() =>
     {
         var memberName = RandomUtility.NextIdentifier();
         member.SetName(context.Authentication, memberName);
     });
 }
Esempio n. 26
0
 public void SetComment(ITypeMember member, TaskContext context)
 {
     member.Dispatcher.Invoke(() =>
     {
         var comment = RandomUtility.NextString();
         member.SetComment(context.Authentication, comment);
     });
 }
Esempio n. 27
0
 /// <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());
 }
Esempio n. 28
0
 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);
    }
Esempio n. 30
0
 /// <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);
 }
Esempio n. 31
0
            static void WriteAttrib(XmlWriter writer, ITypeMember m)
            {
                string s = ApiInfoExtensions.GetAttrib(m);

                if (string.IsNullOrEmpty(s))
                {
                    return;
                }
                writer.WriteAttributeString("attrib", s);
            }
Esempio n. 32
0
        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);
        }
Esempio n. 33
0
        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));
 }
Esempio n. 37
0
        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;
            }
        }
Esempio n. 38
0
        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;
        }
Esempio n. 39
0
 protected virtual string GetCLRTypeName(ITypeMember m)
 {
     CheckTypeForDependancy(m.Type);
     return m.CLRTypeName;
 }
Esempio n. 40
0
 protected virtual string GetCLRTypeName(ITypeMember m)
 {
     AddTypeDependancy(m.Type);
     if (m.Type.IsUnnamedSTLContainer)
         return GetClassName() + "::" + m.CLRTypeName;
     else
         return m.CLRTypeName;
 }
Esempio n. 41
0
 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");
     }
 }
Esempio n. 42
0
 ///<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);
 }
Esempio n. 43
0
 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");
     }
 }
Esempio n. 44
0
 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");
     }
 }
Esempio n. 45
0
 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");
     }
 }
Esempio n. 46
0
 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");
     }
 }
Esempio n. 47
0
 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
        }
Esempio n. 50
0
 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");
     }
 }