예제 #1
0
        void ResolveButtonClick(object sender, EventArgs e)
        {
            SimpleProjectContent     project        = new SimpleProjectContent();
            TypeSystemConvertVisitor convertVisitor = new TypeSystemConvertVisitor(project, "dummy.cs");

            compilationUnit.AcceptVisitor(convertVisitor, null);
            project.UpdateProjectContent(null, convertVisitor.ParsedFile.TopLevelTypeDefinitions, null, null);

            List <ITypeResolveContext> projects = new List <ITypeResolveContext>();

            projects.Add(project);
            projects.AddRange(builtInLibs.Value);

            using (var context = new CompositeTypeResolveContext(projects).Synchronize()) {
                CSharpResolver resolver = new CSharpResolver(context);

                IResolveVisitorNavigator navigator = null;
                if (csharpTreeView.SelectedNode != null)
                {
                    navigator = new NodeListResolveVisitorNavigator(new[] { (AstNode)csharpTreeView.SelectedNode.Tag });
                }
                ResolveVisitor visitor = new ResolveVisitor(resolver, convertVisitor.ParsedFile, navigator);
                visitor.Scan(compilationUnit);
                csharpTreeView.BeginUpdate();
                ShowResolveResultsInTree(csharpTreeView.Nodes, visitor);
                csharpTreeView.EndUpdate();
            }
        }
예제 #2
0
 public virtual void SetUp()
 {
     project             = new SimpleProjectContent();
     context             = new CompositeTypeResolveContext(new [] { project, mscorlib });
     resolver            = new CSharpResolver(context);
     resolver.UsingScope = MakeUsingScope("");
 }
예제 #3
0
 public virtual void SetUp()
 {
     project  = new SimpleProjectContent();
     context  = new CompositeTypeResolveContext(new [] { project, mscorlib, CecilLoaderTests.SystemCore });
     resolver = new CSharpResolver(context);
     resolver.CurrentUsingScope = MakeUsingScope("");
 }
예제 #4
0
        void FindReferencesButtonClick(object sender, EventArgs e)
        {
            if (csharpTreeView.SelectedNode == null)
            {
                return;
            }

            SimpleProjectContent project = new SimpleProjectContent();
            var parsedFile = new TypeSystemConvertVisitor(project, "dummy.cs").Convert(compilationUnit);

            project.UpdateProjectContent(null, parsedFile);

            List <ITypeResolveContext> projects = new List <ITypeResolveContext>();

            projects.Add(project);
            projects.AddRange(builtInLibs.Value);

            using (var context = new CompositeTypeResolveContext(projects).Synchronize()) {
                CSharpResolver resolver = new CSharpResolver(context);

                AstNode node = (AstNode)csharpTreeView.SelectedNode.Tag;
                IResolveVisitorNavigator navigator = new NodeListResolveVisitorNavigator(new[] { node });
                ResolveVisitor           visitor   = new ResolveVisitor(resolver, parsedFile, navigator);
                visitor.Scan(compilationUnit);
                IEntity             entity;
                MemberResolveResult mrr = visitor.GetResolveResult(node) as MemberResolveResult;
                TypeResolveResult   trr = visitor.GetResolveResult(node) as TypeResolveResult;
                if (mrr != null)
                {
                    entity = mrr.Member;
                }
                else if (trr != null)
                {
                    entity = trr.Type.GetDefinition();
                }
                else
                {
                    return;
                }

                FindReferences         fr             = new FindReferences();
                int                    referenceCount = 0;
                FoundReferenceCallback callback       = delegate(AstNode matchNode, ResolveResult result) {
                    referenceCount++;
                };

                var searchScopes = fr.GetSearchScopes(entity);
                navigator = new CompositeResolveVisitorNavigator(searchScopes.Select(s => s.GetNavigator(callback)).ToArray());
                visitor   = new ResolveVisitor(resolver, parsedFile, navigator);
                visitor.Scan(compilationUnit);

                csharpTreeView.BeginUpdate();
                ShowResolveResultsInTree(csharpTreeView.Nodes, visitor);
                csharpTreeView.EndUpdate();

                MessageBox.Show("Found " + referenceCount + " references to " + entity.FullName);
            }
        }
예제 #5
0
        public void SetUp()
        {
            pc = new SimpleProjectContent();
            var cu = new CSharpParser().Parse(new StringReader(program));

            parsedFile = new TypeSystemConvertVisitor(pc, "program.cs").Convert(cu);
            pc.UpdateProjectContent(null, parsedFile);

            ctx = new CompositeTypeResolveContext(new[] { pc, CecilLoaderTests.Mscorlib });

            baseClass    = pc.GetTypeDefinition(string.Empty, "Base", 1, StringComparer.Ordinal);
            nestedClass  = baseClass.NestedTypes.Single();
            derivedClass = pc.GetTypeDefinition(string.Empty, "Derived", 2, StringComparer.Ordinal);
            systemClass  = pc.GetTypeDefinition("NS", "System", 0, StringComparer.Ordinal);
        }
예제 #6
0
        public void GenerateTypeSystem()
        {
            SimpleProjectContent pc     = new SimpleProjectContent();
            CSharpParser         parser = new CSharpParser();

            parser.GenerateTypeSystemMode = true;
            foreach (string fileName in fileNames)
            {
                CompilationUnit cu;
                using (var fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.SequentialScan)) {
                    cu = parser.Parse(fs);
                }
                TypeSystemConvertVisitor cv = new TypeSystemConvertVisitor(pc, fileName);
                pc.UpdateProjectContent(null, cv.Convert(cu));
            }
        }
        internal static IProjectContent ParseTestCase()
        {
            const string fileName = "TypeSystemTests.TestCase.cs";

            CSharpParser    parser = new CSharpParser();
            CompilationUnit cu;

            using (Stream s = typeof(TypeSystemTests).Assembly.GetManifestResourceStream(typeof(TypeSystemTests), fileName)) {
                cu = parser.Parse(s);
            }

            var testCasePC = new SimpleProjectContent();
            CSharpParsedFile parsedFile = new TypeSystemConvertVisitor(testCasePC, fileName).Convert(cu);

            parsedFile.Freeze();
            testCasePC.UpdateProjectContent(null, parsedFile);
            return(testCasePC);
        }
        public void FixtureSetUp()
        {
            const string fileName = "TypeSystemTests.TestCase.cs";

            CSharpParser    parser = new CSharpParser();
            CompilationUnit cu;

            using (Stream s = typeof(TypeSystemTests).Assembly.GetManifestResourceStream(typeof(TypeSystemTests), fileName)) {
                cu = parser.Parse(s);
            }

            testCasePC = new SimpleProjectContent();
            TypeSystemConvertVisitor visitor = new TypeSystemConvertVisitor(testCasePC, fileName);

            cu.AcceptVisitor(visitor, null);
            ParsedFile parsedFile = visitor.ParsedFile;

            ((SimpleProjectContent)testCasePC).UpdateProjectContent(null, parsedFile);
        }
예제 #9
0
        public void ExpansiveInheritance()
        {
            SimpleProjectContent  pc = new SimpleProjectContent();
            DefaultTypeDefinition a  = new DefaultTypeDefinition(pc, string.Empty, "A");
            DefaultTypeDefinition b  = new DefaultTypeDefinition(pc, string.Empty, "B");

            // interface A<in U>
            a.Kind = TypeKind.Interface;
            a.TypeParameters.Add(new DefaultTypeParameter(EntityType.TypeDefinition, 0, "U")
            {
                Variance = VarianceModifier.Contravariant
            });
            // interface B<X> : A<A<B<X>>> { }
            DefaultTypeParameter x = new DefaultTypeParameter(EntityType.TypeDefinition, 0, "X");

            b.TypeParameters.Add(x);
            b.BaseTypes.Add(new ParameterizedType(a, new[] { new ParameterizedType(a, new [] { new ParameterizedType(b, new [] { x }) }) }));

            IType type1 = new ParameterizedType(b, new[] { KnownTypeReference.Double.Resolve(ctx) });
            IType type2 = new ParameterizedType(a, new [] { new ParameterizedType(b, new[] { KnownTypeReference.String.Resolve(ctx) }) });

            Assert.IsFalse(conversions.ImplicitConversion(type1, type2));
        }