Example #1
0
        public void SetParameter_should_apply_new_parameter_names_and_types()
        {
            var method    = MethodName.Parse("TryParse(text:)");
            var newMethod = method.SetParameter(0, "text", TypeName.FromType(typeof(string)));

            Assert.Equal("TryParse(System.String text)", newMethod.ToString());
        }
Example #2
0
        public void Assembly_exists_for_type_specification()
        {
            TypeName tn = TypeName.FromType(typeof(void).MakePointerType());

            var mscorlib = AssemblyName.FromAssemblyName(typeof(object).GetTypeInfo().Assembly.GetName());

            Assert.Equal(mscorlib, tn.Assembly);
        }
Example #3
0
        public void AddParameter_should_apply_new_parameter_names_and_types()
        {
            var method    = MethodName.Parse("TryParse");
            var newMethod = method.AddParameter("text", TypeName.FromType(typeof(string)))
                            .AddParameter("value", TypeName.Parse("Byte&"));

            Assert.Equal("TryParse(System.String text, Byte& value)", newMethod.ToString());
        }
Example #4
0
        public void MakeGenericType_should_produce_correct_closed_generics_and_FullName()
        {
            var      ti         = typeof(C <,> .D <,>).GetTypeInfo();
            TypeName nestedType = TypeName.FromType(typeof(C <,> .D <,>));
            TypeName closed     = nestedType.MakeGenericType(TypeName.Int32, TypeName.String, TypeName.Int32, TypeName.Int16);

            Assert.Equal("Carbonfrost.UnitTests.DotNet.TypeNameTests+C`2+D<Int32, String, Int32, Int16>", closed.FullName);
        }
Example #5
0
        public void FromType_convert_nested_type()
        {
            TypeName name  = TypeName.FromType(typeof(E.Nested));
            TypeName dname = TypeName.FromType(typeof(E));

            Assert.True(name.IsNested);
            Assert.Equal(dname, name.DeclaringType);
        }
Example #6
0
        public void FromType_generic_instance_type()
        {
            TypeName name = TypeName.FromType(typeof(IList <Tuple <string, string[]> >));

            Assert.True(name.IsGenericType);
            Assert.False(name.IsGenericTypeDefinition);
            Assert.Equal("System.Collections.Generic.IList<System.Tuple<System.String, System.String[]>>", name.FullName);
        }
Example #7
0
        public void SetParameter_should_apply_modifiers()
        {
            var method    = MethodName.Parse("TryParse(text:)");
            var newMethod = method.SetParameter(0, "text", TypeName.FromType(typeof(string)),
                                                new [] { TypeName.Parse("Const") }, new [] { TypeName.Parse("Volatile") });

            Assert.Equal("TryParse(modreq(Const) modopt(Volatile) System.String text)", newMethod.ToString());
        }
Example #8
0
        public void MakeByReferenceType_from_byref_type()
        {
            TypeName tn = TypeName.FromType(typeof(int)).MakeByReferenceType();

            Assert.Throws <InvalidOperationException>(() => {
                tn.MakeNullableType();
            });
        }
Example #9
0
        public void FromType_convert_pointer_type()
        {
            TypeName name = TypeName.FromType(typeof(void).MakePointerType());

            Assert.True(name.IsPointer);
            Assert.Equal(TypeName.Void, ((TypeSpecificationName)name).ElementType);
            Assert.Equal("Void*", name.Name);
            Assert.Equal("System.Void*", name.FullName);
        }
Example #10
0
        public void MakeGenericType_nominal()
        {
            TypeName tn = TypeName.FromType(typeof(Converter <,>));

            var gen = tn.MakeGenericType(TypeName.Int16, TypeName.Int32);

            Assert.Equal(tn.Assembly, gen.Assembly);
            Assert.Equal(tn, gen.ElementType);
            Assert.Equal("Converter`2", gen.Name);
        }
Example #11
0
        public void SetParameter_should_apply_on_generics()
        {
            var method = MethodName.Parse("Create``2(``0,``1)");

            Assert.Equal("Create", method.Name);
            var newMethod = method.SetParameter(0, "text", TypeName.FromType(typeof(string)));

            Assert.Equal("Create", newMethod.Name);
            Assert.Equal("Create``2(System.String text, ``1)", newMethod.ToString());
        }
Example #12
0
        public void get_property_name_indexer()
        {
            var type = TypeName.Parse("System.String");
            var prop = type.GetProperty("Chars",
                                        TypeName.FromType(typeof(char)),
                                        new [] { TypeName.FromType(typeof(int)) });

            Assert.Equal("System.String.Chars[System.Int32]", prop.FullName);
            Assert.Equal("System.Char", prop.PropertyType.FullName);
        }
Example #13
0
 public static MethodSignature CreateMethodSignature(TypeName memberCompositeName, MemberMetaInfo member, string methodName)
 {
     Debug.Assert(member.ReturnType != null);
     return(MethodSignatureBuilder.CreateMethod(memberCompositeName, methodName)
            .AddGenerics(T_STATE, GenericConstrainKind.Struct, new TypeName("Decuplr.Serialization.Binary", "IBinaryWriteState<TState>"))
            .AddArgument((RefKind.In, member.ReturnType.Symbol, "member"))
            .AddArgument((RefKind.In, member.ContainingFullType.Symbol, "source"))
            .AddArgument((TypeName.FromGenericArgument(T_STATE), "state"))
            .AddArgument((TypeName.FromType(typeof(Span <byte>)), "data"))
            .WithReturn(TypeName.FromType <int>()));
 }
Example #14
0
        public void FromType_generic_type_definition()
        {
            TypeName name = TypeName.FromType(typeof(Tuple <, , ,>));

            Assert.True(name.IsGenericType);
            Assert.True(name.IsGenericTypeDefinition);
            Assert.Equal("System.Tuple`4", name.FullName);
            Assert.Equal(4, name.GenericParameterCount);
            Assert.Equal(typeof(object).GetTypeInfo().Assembly.FullName, name.Assembly.FullName);
            Assert.Equal(new [] { "T1", "T2", "T3", "T4" }, name.GenericParameters.Select(t => t.Name));
        }
Example #15
0
        public void FromType_convert_array_type()
        {
            TypeName name = TypeName.FromType(typeof(void).MakeArrayType(2));

            Assert.True(name.IsArray);

            ArrayTypeName array = (ArrayTypeName)name;

            Assert.Equal(TypeName.Void, array.ElementType);
            Assert.Equal(2, array.Dimensions.Count);
            Assert.Equal("Void[,]", array.Name);
        }
Example #16
0
        public void FromType_generic_type_definition_nested()
        {
            TypeName name = TypeName.FromType(typeof(Dictionary <,> .ValueCollection));

            Assert.True(name.IsGenericType);
            Assert.True(name.IsGenericTypeDefinition);
            Assert.Equal("System.Collections.Generic.Dictionary`2+ValueCollection", name.FullName);
            Assert.Equal(2, name.GenericParameterCount);
            Assert.Equal(typeof(object).GetTypeInfo().Assembly.FullName, name.Assembly.FullName);

            Assert.Equal(new [] { "TKey", "TValue" }, name.GenericParameters.Select(t => t.Name));
            Assert.Equal(name, name.GenericParameters[0].DeclaringType);
        }
Example #17
0
        public void WithDeclaringType_should_update_it()
        {
            TypeName parentType = TypeName.FromType(typeof(int));
            TypeName name       = TypeName.FromType(typeof(string));

            name = name.WithDeclaringType(parentType);
            Assert.Equal("String", name.Name);
            Assert.Equal("System.Int32+String", name.FullName);
            Assert.Equal("System", name.Namespace);
            Assert.Equal("System.Int32", name.DeclaringType.FullName);
            Assert.Same(parentType.Assembly, name.DeclaringType.Assembly);
            Assert.Same(parentType.Assembly, name.Assembly);
        }
        public void Format_type_display_name_generic_nested()
        {
            var type = TypeName.FromType(typeof(Dictionary <,> .KeyCollection));

            MetadataNameFormat format = new MetadataNameFormat();

            format.IncludeTypeParameters = true;

            string expected = "System.Collections.Generic.Dictionary<TKey, TValue>+KeyCollection";

            Assert.Equal(expected, format.Format(type));
            Assert.Equal(expected, type.ToString(null, format));
        }
Example #19
0
        /// <returns>Next state arg name</returns>
        private string LoadNextWriteState <TChainedMethod>(CodeNodeBuilder node, TChainedMethod chainedMethod) where TChainedMethod : MemberChainedMethods <TChainedMethod>
        {
            const string nextState = "nextState";

            var tstateTypeName = TypeName.FromGenericArgument(SerializeWriterChainedMethods.T_STATE);
            var state          = chainedMethod[tstateTypeName];
            var tsource        = chainedMethod[TypeName.FromType(_member.ContainingFullType.Symbol)];

            node.If($"!{state}.Write({tsource}, out var {nextState})", node => {
                node.Return();
            });

            return(nextState);
        }
        public void Format_use_generic_parameter_compact_format()
        {
            TypeName t = TypeName.FromType(typeof(IDictionary <Delegate, int>));

            MetadataNameFormat format = new MetadataNameFormat();

            format.DefaultFormatString[SymbolType.Parameter] = "Cv";
            format.IncludeTypeParameters = true;

            string expected = "System.Collections.Generic.IDictionary<Delegate, Int32>";

            Assert.Equal(expected, format.Format(t));
            Assert.Equal(expected, t.ToString(null, format));
        }
        public void Format_use_generic_type_generic_parameter_names()
        {
            TypeName           m      = TypeName.FromType(typeof(Tuple <, , ,>));
            MetadataNameFormat format = new MetadataNameFormat();

            format.IncludeTypeParameters  = true;
            format.IncludeTypeConstraints = false;
            format.IncludeVariance        = false;

            string expected = "System.Tuple<T1, T2, T3, T4>";

            Assert.Equal(expected, format.Format(m));
            Assert.Equal(expected, m.ToString(null, format));
        }
Example #22
0
        public void FromType_should_get_closed_inherited_generic_arguments()
        {
            var s = new C <int, long> .D <string, string>();

            // proof, for reference:
            var args = s.GetType().GetTypeInfo().GetGenericArguments();

            Assume.Equal(new [] { typeof(int), typeof(long), typeof(string), typeof(string) }, args);

            var t = (GenericInstanceTypeName)TypeName.FromType(s.GetType());

            Assert.HasCount(4, t.GenericArguments);
            Assert.Equal(new [] { "Int32", "Int64", "String", "String" },
                         t.GenericArguments.Select(u => u.Name).ToArray());
        }
Example #23
0
        public void FromType_generic_type_definition_nested_generic()
        {
            var      ti   = typeof(C <,> .D <,>).GetTypeInfo();
            TypeName name = TypeName.FromType(typeof(C <,> .D <,>));

            // proof, for reference:
            Assume.HasCount(4, ti.GetGenericArguments());
            Assume.Equal("D`2", ti.Name);
            Assume.Equal("Carbonfrost.UnitTests.DotNet.TypeNameTests+C`2+D`2", ti.FullName);

            Assert.True(name.IsGenericType);
            Assert.True(name.IsGenericTypeDefinition);
            Assert.Equal("Carbonfrost.UnitTests.DotNet.TypeNameTests+C`2+D`2", name.FullName);
            Assert.Equal(4, name.GenericParameterCount); // inherited generics
        }
 protected static IEnumerable <MethodArg> GetRelyingArgs(IEnumerable <MemberMetaInfo> relyingMembers) => relyingMembers.Select((member, i) => new MethodArg(RefKind.In, TypeName.FromType(member.ReturnType.Symbol), $"args{i}"));
Example #25
0
        public void FromType_should_apply_to_types_without_namespaces()
        {
            var type = TypeName.FromType(typeof(NoNamespaceType));

            Assert.Equal("", type.Namespace);
        }
Example #26
0
        public void MakeGenericType_mismatch_arg_count()
        {
            TypeName tn = TypeName.FromType(typeof(Converter <,>));

            tn.MakeGenericType(TypeName.Int16);
        }