Exemple #1
0
        public void TestFixtureAttributeRemoved()
        {
            // Add the test class first.
            TestFixtureAttributeAdded();

            // Create an old compilation unit with the test class
            // having a [TestFixture] attribute.
            DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent);
            MockClass newClass             = new MockClass(projectContent, "RootNamespace.MyNewTestFixture");

            newClass.Attributes.Add(new MockAttribute("TestFixture"));
            oldUnit.Classes.Add(newClass);

            // Create a new compilation unit with the test class
            // but without a [TestFixture] attribute.
            DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);

            newClass = new MockClass(projectContent, "RootNamespace.MyNewTestFixture");
            newUnit.Classes.Add(newClass);

            // Update TestProject's parse info.
            testProject.UpdateParseInfo(oldUnit, newUnit);

            Assert.IsFalse(testProject.TestClasses.Contains("RootNamespace.MyNewTestFixture"),
                           "Class should have been removed.");
        }
Exemple #2
0
        public void SetUpFixture()
        {
            resolver = new PythonResolver();
            ParseInformation parseInfo = new ParseInformation();

            mockProjectContent = new MockProjectContent();
            mockProjectContent.NamespacesToAdd.Add("Test");
            myTestClass = new MockClass(mockProjectContent, "MyTestClass");
            ArrayList namespaceItems = new ArrayList();

            namespaceItems.Add(myTestClass);
            mockProjectContent.AddExistingNamespaceContents("MyNamespace", namespaceItems);

            DefaultCompilationUnit cu = new DefaultCompilationUnit(mockProjectContent)
            {
                ErrorsDuringCompile = true
            };

            parseInfo.SetCompilationUnit(cu);

            // Add usings.
            DefaultUsing newUsing = new DefaultUsing(cu.ProjectContent);

            newUsing.Usings.Add("MyNamespace");
            cu.UsingScope.Usings.Add(newUsing);

            results = resolver.CtrlSpace(0, "".Length, parseInfo, "", ExpressionContext.Default);
        }
        public void ParserInfoForDifferentProjectOldCompilationUnitNull()
        {
            MockProjectContent     differentProjectContent = new MockProjectContent();
            DefaultCompilationUnit newUnit = new DefaultCompilationUnit(differentProjectContent);

            Assert.IsFalse(testProject.IsParseInfoForThisProject(null, newUnit));
        }
Exemple #4
0
        public void Init()
        {
            base.InitBase();

            DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent);

            oldUnit.Classes.Add(outerClass);

            // Create new compilation unit with extra class.
            DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);
            MockClass newOuterClass        = new MockClass("MyTests.A");

            newOuterClass.ProjectContent = projectContent;
            projectContent.Classes.Add(newOuterClass);
            newOuterClass.SetCompoundClass(newOuterClass);
            newUnit.Classes.Add(newOuterClass);

            // Create the inner test class.
            // Note the use of the DotNetName "MyTests.A+InnerTest".
            MockClass newInnerClass = new MockClass("MyTests.A.InnerATestMod", "MyTests.A+InnerATestMod");

            newInnerClass.Attributes.Add(new MockAttribute("TestFixture"));
            newInnerClass.ProjectContent = projectContent;
            newInnerClass.DeclaringType  = outerClass;            // Declaring type is outer class.
            newOuterClass.InnerClasses.Add(newInnerClass);

            // Update TestProject's parse info.
            testProject.UpdateParseInfo(oldUnit, newUnit);
        }
Exemple #5
0
 private Class GetTheRealType(NCC.MType objectType, DefaultCompilationUnit cu)
 {
     if (objectType is NCC.MType.Class)
     {
         return(new Class(((NCC.MType.Class)objectType).tycon, cu, false));
     }
     else if (objectType is NCC.MType.Array)
     {
         return(new Class("System.Array", cu));
     }
     else if (objectType is NCC.MType.Fun)
     {
         return(GetTheRealType(((NCC.MType.Fun)objectType).to.Fix(), cu));
     }
     else if (objectType is NCC.MType.Ref)
     {
         return(GetTheRealType(((NCC.MType.Ref)objectType).t.Fix(), cu));
     }
     else if (objectType is NCC.MType.Out)
     {
         return(GetTheRealType(((NCC.MType.Out)objectType).t.Fix(), cu));
     }
     else
     {
         return(null);
     }
 }
        public void Init()
        {
            base.InitBase();

            DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent);

            oldUnit.Classes.Add(outerClass);

            // Create new compilation unit with inner class that no longer has the TestFixture attribute.
            DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);
            MockClass newOuterClass        = new MockClass("MyTests.A");

            newOuterClass.ProjectContent = projectContent;
            projectContent.Classes.Add(newOuterClass);
            newOuterClass.SetCompoundClass(newOuterClass);
            newUnit.Classes.Add(newOuterClass);

            // Create the inner test class.
            MockClass newInnerClass = new MockClass("MyTests.A.InnerATest", "MyTests.A+InnerATest");

            newInnerClass.ProjectContent = projectContent;
            newInnerClass.DeclaringType  = outerClass;            // Declaring type is outer class.
            newInnerClass.SetCompoundClass(newInnerClass);
            newOuterClass.InnerClasses.Add(newInnerClass);

            // Update TestProject's parse info.
            testProject.UpdateParseInfo(oldUnit, newUnit);
        }
        // usingMode: 0 = one using-statement for each namespace (correctly cased)
        //            1 = mixture of using statements and default imports (incorrectly cased)
        //            2 = all default imports (incorrectly cased)
        ICompilationUnit Prepare(LanguageProperties language, int usingMode)
        {
            DefaultProjectContent pc = new DefaultProjectContent();

            pc.ReferencedContents.Add(projectContentRegistry.Mscorlib);
            pc.Language = language;
            DefaultCompilationUnit cu = new DefaultCompilationUnit(pc);

            if (usingMode == 1)
            {
                cu.Usings.Add(CreateUsing(pc, "syStEm.coLLectIons"));
                pc.DefaultImports = new DefaultUsing(pc);
                pc.DefaultImports.Usings.Add("syStEm");
                pc.DefaultImports.Usings.Add("syStEm.coLLEctionS.GeNeRic");
            }
            else if (usingMode == 2)
            {
                pc.DefaultImports = new DefaultUsing(pc);
                pc.DefaultImports.Usings.Add("syStEm");
                pc.DefaultImports.Usings.Add("syStEm.coLLEctioNs");
                pc.DefaultImports.Usings.Add("syStEm.coLLEctionS.GeNeRic");
            }
            else                 // usingMode == 0
            {
                cu.Usings.Add(CreateUsing(pc, "System"));
                cu.Usings.Add(CreateUsing(pc, "System.Collections"));
                cu.Usings.Add(CreateUsing(pc, "System.Collections.Generic"));
            }
            return(cu);
        }
        public void GetInitializeComponentWhenNoClassesInCompilationUnit()
        {
            DefaultCompilationUnit unit      = new DefaultCompilationUnit(new MockProjectContent());
            ParseInformation       parseInfo = new ParseInformation(unit);

            Assert.IsNull(RubyDesignerGenerator.GetInitializeComponents(unit));
        }
        void CreateParseInfo()
        {
            MockProjectContent     projectContent = new MockProjectContent();
            DefaultCompilationUnit unit           = new DefaultCompilationUnit(projectContent);

            parseInfo = new ParseInformation(unit);
        }
        public void NewClassInParserInfo()
        {
            // Create old compilation unit.
            DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent);
            MockClass mockClass            = (MockClass)testClass.Class;

            mockClass.SetCompoundClass(mockClass);
            oldUnit.Classes.Add(testClass.Class);

            // Create new compilation unit with extra class.
            DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);

            newUnit.Classes.Add(testClass.Class);
            MockClass newClass = new MockClass("RootNamespace.MyNewTestFixture");

            newClass.Attributes.Add(new MockAttribute("TestFixture"));
            newClass.ProjectContent = projectContent;
            newClass.SetCompoundClass(newClass);
            newUnit.Classes.Add(newClass);

            // Update TestProject's parse info.
            testProject.UpdateParseInfo(oldUnit, newUnit);

            Assert.IsTrue(testProject.TestClasses.Contains("RootNamespace.MyNewTestFixture"));
            Assert.AreEqual(1, classesAdded.Count);
            Assert.AreSame(newClass, classesAdded[0].Class);
        }
Exemple #11
0
        public void TestFixtureAttributeAdded()
        {
            // Create an old compilation unit with the test class
            // but without a [TestFixture] attribute.
            DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent);
            MockClass newClass             = new MockClass("RootNamespace.MyNewTestFixture");

            newClass.ProjectContent = projectContent;
            newClass.SetCompoundClass(newClass);
            oldUnit.Classes.Add(newClass);

            // Create a new compilation unit with the test class
            // having a [TestFixture] attribute.
            DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);

            newClass = new MockClass("RootNamespace.MyNewTestFixture");
            newClass.Attributes.Add(new MockAttribute("TestFixture"));
            newClass.ProjectContent = projectContent;
            newClass.SetCompoundClass(newClass);
            newUnit.Classes.Add(newClass);

            // Update TestProject's parse info.
            testProject.UpdateParseInfo(oldUnit, newUnit);

            Assert.IsTrue(testProject.TestClasses.Contains("RootNamespace.MyNewTestFixture"),
                          "New class should have been added to the set of TestClasses.");
        }
		public NRefactoryASTConvertVisitor(IProjectContent projectContent, SupportedLanguage language)
		{
			if (language == SupportedLanguage.VBNet)
				cu = new VBNetCompilationUnit(projectContent);
			else
				cu = new DefaultCompilationUnit(projectContent);
		}
Exemple #13
0
        private ICompilationUnitBase parse_the_file(string fileName, string contents)
        {
            if (IdeApp.ProjectOperations.CurrentSelectedProject == null)
            {
                return(null);
            }

            lock (syncObject)
            {
                try
                {
                    ReloadReferences();
                    ReloadFiles(fileName, contents);

                    CompletionStageHandler handler = new CompletionStageHandler(make_type);
                    cu = new DefaultCompilationUnit();
                    engine.GetTypeTree(handler);
                    return(cu);
                }
                catch (Exception ex)
                {
                    System.Console.WriteLine("ERROR");
                    System.Console.WriteLine(ex.Message);
                    System.Console.WriteLine(ex.StackTrace);
                    return(null);
                }
            }
        }
        public void SetUpFixture()
        {
            resolver           = new PythonResolver();
            mockProjectContent = new ICSharpCode.Scripting.Tests.Utils.MockProjectContent();
            mockProjectContent.NamespacesToAdd.Add("Test");
            myTestClass = new MockClass(mockProjectContent, "MyTestClass");
            List <ICompletionEntry> namespaceItems = new List <ICompletionEntry>();

            namespaceItems.Add(myTestClass);
            mockProjectContent.AddExistingNamespaceContents("MyNamespace", namespaceItems);

            DefaultCompilationUnit cu = new DefaultCompilationUnit(mockProjectContent);

            // Add usings.
            DefaultUsing newUsing = new DefaultUsing(cu.ProjectContent);

            newUsing.Usings.Add("MyNamespace");
            DefaultUsingScope usingScope = new DefaultUsingScope();

            usingScope.Usings.Add(newUsing);
            cu.UsingScope = usingScope;
            ParseInformation parseInfo = new ParseInformation(cu);

            results = resolver.CtrlSpace(0, "".Length, parseInfo, "", ExpressionContext.Default);
        }
Exemple #15
0
        public ICompilationUnit Parse(IProjectContent projectContent, string fileName, string fileContent)
        {
            DefaultCompilationUnit compilationUnit = new DefaultCompilationUnit(projectContent);

            compilationUnit.FileName = fileName;
            return(compilationUnit);
        }
        public void MethodRemovedInParserInfo()
        {
            // Create old compilation unit.
            DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent);

            oldUnit.Classes.Add(testClass.Class);

            // Create new compilation unit.
            DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);

            newUnit.Classes.Add(testClass.Class);

            // Add a new method to a new compound class.
            MockClass compoundClass = new MockClass(projectContent, "RootNamespace.MyTestFixture");

            compoundClass.Attributes.Add(new MockAttribute("TestFixture"));
            MockClass mockClass = (MockClass)testClass.Class;

            mockClass.SetCompoundClass(compoundClass);

            // Monitor test methods removed.
            List <TestMember> methodsRemoved = new List <TestMember>();

            testClass.TestMembers.TestMemberRemoved += delegate(Object source, TestMemberEventArgs e)
            { methodsRemoved.Add(e.TestMember); };

            // Update TestProject's parse info.
            testProject.UpdateParseInfo(oldUnit, newUnit);

            Assert.IsFalse(testClass.TestMembers.Contains("TestMethod"));
            Assert.AreEqual(1, methodsRemoved.Count);
            Assert.AreSame(testMethod.Member, methodsRemoved[0].Member);
        }
Exemple #17
0
        public void Init()
        {
            base.InitBase();

            DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent);

            oldUnit.Classes.Add(outerClass);

            // Create new compilation unit with inner class that has its method renamed.
            DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);
            MockClass newOuterClass        = new MockClass(projectContent, "MyTests.A");

            projectContent.Classes.Add(newOuterClass);
            newUnit.Classes.Add(newOuterClass);

            // Create the inner test class.
            MockClass newInnerClass = new MockClass(projectContent, "MyTests.A.InnerATest", outerClass);

            newInnerClass.SetDotNetName("MyTests.A+InnerATest");
            newInnerClass.Attributes.Add(new MockAttribute("TestFixture"));
            newOuterClass.InnerClasses.Add(newInnerClass);

            MockMethod method = new MockMethod(newInnerClass, "FooBarRenamed");

            method.Attributes.Add(new MockAttribute("Test"));
            newInnerClass.Methods.Add(method);
            outerClass.InnerClasses.Add(newInnerClass);

            // Update TestProject's parse info.
            testProject.UpdateParseInfo(oldUnit, newUnit);

            innerTestClass = testProject.TestClasses["MyTests.A+InnerATest"];
        }
        public void Init()
        {
            // Create a project to display.
            project      = new MockCSharpProject();
            project.Name = "TestProject";
            ReferenceProjectItem nunitFrameworkReferenceItem = new ReferenceProjectItem(project);

            nunitFrameworkReferenceItem.Include = "NUnit.Framework";
            ProjectService.AddProjectItem(project, nunitFrameworkReferenceItem);

            // Add a test class.
            projectContent          = new MockProjectContent();
            projectContent.Language = LanguageProperties.None;
            MockClass c = new MockClass("RootNamespace.MyTestFixture");

            c.Attributes.Add(new MockAttribute("TestFixture"));
            c.ProjectContent = projectContent;
            c.SetCompoundClass(c);
            MockMethod test1Method = new MockMethod("Test1");

            test1Method.DeclaringType = c;
            test1Method.Attributes.Add(new MockAttribute("Test"));
            c.Methods.Add(test1Method);

            // Test 2 method is from a duplicate test class.
            MockMethod test2Method = new MockMethod("Test2");

            test2Method.DeclaringType = c;
            test2Method.Attributes.Add(new MockAttribute("Test"));
            c.Methods.Add(test2Method);
            projectContent.Classes.Add(c);

            testProject = new TestProject(project, projectContent);

            // Make sure test methods are created, otherwise
            // the Test2 method will never be looked at due to lazy evaluation
            // of test method.s
            int count = testProject.TestClasses[0].TestMethods.Count;

            // Change the name of the second test class.
            DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent);

            oldUnit.Classes.Add(c);
            c.Methods.Remove(test2Method);             // Remove duplicate test class method.


            // Create new compilation unit with inner class that has its method renamed.
            DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);
            MockClass newTestClass         = new MockClass("RootNamespace.MyNewTestFixture");

            newTestClass.ProjectContent = projectContent;
            newTestClass.Attributes.Add(new MockAttribute("TestFixture"));
            newTestClass.SetCompoundClass(newTestClass);
            projectContent.Classes.Add(newTestClass);
            newTestClass.Methods.Add(test2Method);
            newUnit.Classes.Add(newTestClass);

            testProject.UpdateParseInfo(oldUnit, newUnit);
        }
Exemple #19
0
        /// <summary>
        /// Creates a compilation unit with one class called Test.
        /// </summary>
        protected virtual ICompilationUnit CreateCompilationUnit(IProjectContent projectContent)
        {
            ICompilationUnit compilationUnit = new DefaultCompilationUnit(projectContent);

            testClass = new MockClass(projectContent, "Test");
            compilationUnit.Classes.Add(testClass);
            return(compilationUnit);
        }
Exemple #20
0
        /// <summary>
        /// Builds Visual Basic's "My" namespace for the specified project.
        /// </summary>
        public static void BuildNamespace(VBNetProject project, IProjectContent pc)
        {
            ICompilationUnit cu = new DefaultCompilationUnit(pc);
            //cu.FileName = "GeneratedMyNamespace.vb"; // leave FileName null - fixes SD2-854
            string ns;

            if (project.RootNamespace == null || project.RootNamespace.Length == 0)
            {
                ns = "My";
            }
            else
            {
                ns = project.RootNamespace + ".My";
            }
            IClass myApp  = CreateMyApplication(cu, project, ns);
            IClass myComp = CreateMyComputer(cu, project, ns);

            cu.Classes.Add(myApp);
            cu.Classes.Add(myComp);

            IClass myForms = null;

            if (project.OutputType == OutputType.WinExe)
            {
                myForms = CreateMyForms(cu, project, ns);
                cu.Classes.Add(myForms);
            }
            DefaultClass c = new DefaultClass(cu, ns + ".MyProject");

            c.ClassType = ClassType.Module;
            c.Modifiers = ModifierEnum.Internal | ModifierEnum.Partial | ModifierEnum.Sealed | ModifierEnum.Synthetic;
            c.Attributes.Add(new DefaultAttribute(CreateTypeRef(cu, "Microsoft.VisualBasic.HideModuleNameAttribute")));

            // we need to use GetClassReturnType instead of DefaultReturnType because we need
            // a reference to the compound class.
            c.Properties.Add(new DefaultProperty("Application",
                                                 new GetClassReturnType(pc, myApp.FullyQualifiedName, 0),
                                                 ModifierEnum.Public | ModifierEnum.Static,
                                                 DomRegion.Empty, DomRegion.Empty, c));
            c.Properties.Add(new DefaultProperty("Computer",
                                                 new GetClassReturnType(pc, myComp.FullyQualifiedName, 0),
                                                 ModifierEnum.Public | ModifierEnum.Static,
                                                 DomRegion.Empty, DomRegion.Empty, c));
            if (myForms != null)
            {
                c.Properties.Add(new DefaultProperty("Forms",
                                                     new GetClassReturnType(pc, myForms.FullyQualifiedName, 0),
                                                     ModifierEnum.Public | ModifierEnum.Static,
                                                     DomRegion.Empty, DomRegion.Empty, c));
            }
            c.Properties.Add(new DefaultProperty("User",
                                                 new GetClassReturnType(pc, "Microsoft.VisualBasic.ApplicationServices.User", 0),
                                                 ModifierEnum.Public | ModifierEnum.Static,
                                                 DomRegion.Empty, DomRegion.Empty, c));
            cu.Classes.Add(c);
            pc.UpdateCompilationUnit(null, cu, cu.FileName);
        }
        public void ExpressionResultContextShowItemReturnsTrueForIMethod()
        {
            MockProjectContent     projectContent = new MockProjectContent();
            DefaultCompilationUnit unit           = new DefaultCompilationUnit(projectContent);
            DefaultClass           c      = new DefaultClass(unit, "MyClass");
            DefaultMethod          method = new DefaultMethod(c, "Test");

            Assert.IsTrue(expressionResult.Context.ShowEntry(method));
        }
Exemple #22
0
        public PythonModuleCompletionItems(PythonStandardModuleType moduleType)
        {
            projectContent  = new DefaultProjectContent();
            compilationUnit = new DefaultCompilationUnit(projectContent);
            moduleClass     = new DefaultClass(compilationUnit, moduleType.Name);

            AddCompletionItemsForType(moduleType.Type);
            AddStandardCompletionItems();
        }
Exemple #23
0
        public void Init()
        {
            DefaultProjectContent  projectContent = new DefaultProjectContent();
            DefaultCompilationUnit unit           = new DefaultCompilationUnit(projectContent);

            existingParseInfo = new ParseInformation(unit);

            parserService = new MockParserService();
            parserService.SetExistingParseInformation(@"d:\projects\test.xml", existingParseInfo);
        }
 public NRefactoryASTConvertVisitor(IProjectContent projectContent, SupportedLanguage language)
 {
     if (language == SupportedLanguage.VBNet)
     {
         cu = new VBNetCompilationUnit(projectContent);
     }
     else
     {
         cu = new DefaultCompilationUnit(projectContent);
     }
 }
        public PythonResolverTestsHelper(string code)
        {
            ProjectContent = new ScriptingUtils.MockProjectContent();
            PythonParser parser   = new PythonParser();
            string       fileName = @"test.py";

            CompilationUnit = parser.Parse(ProjectContent, fileName, code) as DefaultCompilationUnit;

            ParseInfo = new ParseInformation(CompilationUnit);
            Resolver  = new PythonResolver();
        }
        public void TestProjectRemovesTestClassWhenItIsNoLongerATestClass()
        {
            testFrameworks.RemoveTestClass(myTestClass);

            DefaultCompilationUnit newUnit = new DefaultCompilationUnit(myTestClass.ProjectContent);

            newUnit.Classes.Add(myTestClass);

            testProject.UpdateParseInfo(oldUnit, newUnit);

            Assert.AreEqual(0, testProject.TestClasses.Count);
        }
        public void Init()
        {
            testFrameworks = new MockRegisteredTestFrameworks();
            myTestClass    = MockClass.CreateMockClassWithoutAnyAttributes();
            myTestClass.SetDotNetName("MyTests");
            testFrameworks.AddTestClass(myTestClass);

            oldUnit = new DefaultCompilationUnit(myTestClass.ProjectContent);
            oldUnit.Classes.Add(myTestClass);

            testProject = new TestProject(myTestClass.Project, myTestClass.ProjectContent, testFrameworks);
        }
        public void Init()
        {
            MockProjectContent projectContent = new MockProjectContent();
            MockProjectContent winFormsReferenceProjectContent = new MockProjectContent();

            winFormsReferenceProjectContent.AddExistingNamespaceContents("System.Windows.Forms", new ArrayList());
            projectContent.ReferencedContents.Add(winFormsReferenceProjectContent);
            DefaultCompilationUnit unit = new DefaultCompilationUnit(projectContent);

            parseInfo = new ParseInformation(unit);

            resolverContext = new PythonResolverContext(parseInfo);
        }
        public void Init()
        {
            projectContent = new MockProjectContent();
            completion     = new PythonImportCompletion(projectContent);

            DefaultCompilationUnit unit      = new DefaultCompilationUnit(projectContent);
            ParseInformation       parseInfo = new ParseInformation(unit);

            c = new DefaultClass(unit, "Class");
            List <ICompletionEntry> namespaceItems = new List <ICompletionEntry>();

            namespaceItems.Add(c);
            projectContent.AddExistingNamespaceContents("System", namespaceItems);
        }
Exemple #30
0
        public void NewClassInParserInfo()
        {
            // Create new compilation unit with extra class.
            DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);
            MockClass newClass             = new MockClass(projectContent, "RootNamespace.MyNewTestFixture");

            newClass.Attributes.Add(new MockAttribute("TestFixture"));
            newUnit.Classes.Add(newClass);

            // Update TestProject's parse info.
            testProject.UpdateParseInfo(null, newUnit);

            Assert.IsTrue(testProject.TestClasses.Contains("RootNamespace.MyNewTestFixture"));
        }
        public void Init()
        {
            string code = "from System import Console";

            importExpression = new PythonImportExpression(code);
            resolveResult    = new PythonImportModuleResolveResult(importExpression);

            projectContent = new MockProjectContent();
            DefaultCompilationUnit  unit           = new DefaultCompilationUnit(projectContent);
            DefaultClass            c              = new DefaultClass(unit, "Test");
            List <ICompletionEntry> namespaceItems = new List <ICompletionEntry>();

            namespaceItems.Add(c);
            projectContent.AddExistingNamespaceContents("System", namespaceItems);
        }
		public void NestedInterfaceInGenericClass()
		{
			// See SD2-1626
			DefaultProjectContent pc = new DefaultProjectContent();
			pc.ReferencedContents.Add(SharedProjectContentRegistryForTests.Instance.Mscorlib);
			
			DefaultCompilationUnit cu = new DefaultCompilationUnit(pc);
			DefaultClass container = new DefaultClass(cu, "TestClass");
			container.TypeParameters.Add(new DefaultTypeParameter(container, "T", 0));
			
			DefaultClass innerClass = new DefaultClass(cu, container);
			innerClass.FullyQualifiedName = "TestClass.INestedInterface";
			innerClass.ClassType = ClassType.Interface;
			innerClass.TypeParameters.Add(new DefaultTypeParameter(innerClass, "T", 0));
			innerClass.Properties.Add(new DefaultProperty(innerClass, "P") {
			                          	ReturnType = new GenericReturnType(innerClass.TypeParameters[0]),
			                          	CanGet = true
			                          });
			container.InnerClasses.Add(innerClass);
			pc.AddClassToNamespaceList(container);
			
			DefaultClass targetClass = new DefaultClass(cu, "TargetClass");
			List<AbstractNode> nodes = new List<AbstractNode>();
			
			IReturnType interf = new SearchClassReturnType(pc, targetClass, 0, 0, "TestClass.INestedInterface", 1);
			interf = new ConstructedReturnType(interf, new IReturnType[] { SharedProjectContentRegistryForTests.Instance.Mscorlib.GetClass("System.String", 0).DefaultReturnType });
			
			CSharpCodeGenerator codeGen = new CSharpCodeGenerator();
			codeGen.ImplementInterface(nodes, interf, true, targetClass);
			
			Assert.AreEqual(1, nodes.Count);
			CSharpOutputVisitor output = new CSharpOutputVisitor();
			output.Options.IndentationChar = ' ';
			output.Options.IndentSize = 2;
			nodes[0].AcceptVisitor(output, null);
			Assert.AreEqual("string TestClass<string>.INestedInterface.P {\n  get {\n    throw new NotImplementedException();\n  }\n}", output.Text.Replace("\r", "").Trim());
		}
Exemple #33
0
 private Class GetTheRealType (NCC.MType objectType, DefaultCompilationUnit cu)
 {
     if (objectType is NCC.MType.Class)
     {
         return new Class (((NCC.MType.Class)objectType).tycon, cu, false);
     }
     else if (objectType is NCC.MType.Array)
     {
         return new Class ("System.Array", cu);
     }
     else if (objectType is NCC.MType.Fun)
     {
         return GetTheRealType (((NCC.MType.Fun)objectType).to.Fix (), cu);
     }
     else if (objectType is NCC.MType.Ref)
     {
         return GetTheRealType (((NCC.MType.Ref)objectType).t.Fix (), cu);
     }
     else if (objectType is NCC.MType.Out)
     {
         return GetTheRealType (((NCC.MType.Out)objectType).t.Fix (), cu);
     }
     else
     {
         return null;
     }
 }
Exemple #34
0
 private ICompilationUnitBase parse_the_file (string fileName, string contents)
 {
     if (IdeApp.ProjectOperations.CurrentSelectedProject == null)
         return null;
     
     lock (syncObject)
     {
         try
         {
             ReloadReferences ();
             ReloadFiles (fileName, contents);
             
             CompletionStageHandler handler = new CompletionStageHandler (make_type);
             cu = new DefaultCompilationUnit ();
             engine.GetTypeTree (handler);
             return cu;
         }
         catch (Exception ex)
         {
             System.Console.WriteLine ("ERROR");
             System.Console.WriteLine (ex.Message);
             System.Console.WriteLine (ex.StackTrace);
             return null;
         }
     }
 }
Exemple #35
0
        public Class(NCC.TypeInfo tinfo, DefaultCompilationUnit cu, bool addMembers): base (cu)
        {
            this.tinfo = tinfo;
            
            this.FullyQualifiedName = tinfo.FrameworkTypeName.TrimEnd('*');
            if (this.FullyQualifiedName.Contains("`"))
                this.FullyQualifiedName = this.FullyQualifiedName.TrimEnd ('1', '2', '3', '4').TrimEnd('`');

            
            if (tinfo.IsEnum)
                classType = ClassType.Enum;
            else if (tinfo.IsInterface)
                classType = ClassType.Interface;
            else if (tinfo.IsValueType)
                classType = ClassType.Struct;
            else if (tinfo.IsDelegate)
                classType = ClassType.Delegate;
            else
                classType = ClassType.Class;
            
            this.region = GetRegion (tinfo.Location);
            this.bodyRegion = GetRegion (tinfo.Location);
            
            ModifierEnum mod = (ModifierEnum)0;
            if ((tinfo.Attributes & NCC.NemerleAttributes.Private) != 0)
                mod |= ModifierEnum.Private;
            if ((tinfo.Attributes & NCC.NemerleAttributes.Internal) != 0)
                mod |= ModifierEnum.Internal;
            if ((tinfo.Attributes & NCC.NemerleAttributes.Protected) != 0)
                mod |= ModifierEnum.Protected;
            if ((tinfo.Attributes & NCC.NemerleAttributes.Public) != 0)
                mod |= ModifierEnum.Public;
            if ((tinfo.Attributes & NCC.NemerleAttributes.Abstract) != 0)
                mod |= ModifierEnum.Abstract;
            if ((tinfo.Attributes & NCC.NemerleAttributes.Sealed) != 0)
                mod |= ModifierEnum.Sealed;
                
            modifiers = mod;
            
            if (tinfo.Typarms.Length > 0)
            {
                this.genericParamters = new GenericParameterList ();
                foreach (NCC.StaticTyVar typarm in tinfo.Typarms)
                {
                    genericParamters.Add (GetGenericParameter (typarm));
                }
            }
            
            if (addMembers || tinfo.IsDelegate)
            {
                foreach (NCC.IMember member in tinfo.GetMembers ())
                {
                    if (member.Name.StartsWith ("_N") || member.Location.Line == tinfo.Location.Line)
                        continue;
                        
                    NCC.MemberKind m = member.GetKind ();
                    
                    if (m is NCC.MemberKind.Field)
                    {
                        NCC.MemberKind.Field f = (NCC.MemberKind.Field)m;
                        if (f.field.Name != "value__")
                            fields.Add (new Field (this, f.field));
                    }
                    else if (m is NCC.MemberKind.Method)
                    {
                        NCC.MemberKind.Method mt = (NCC.MemberKind.Method)m;
                        if (mt.method.Name.StartsWith ("get_") || mt.method.Name.StartsWith ("set_") || 
                            mt.method.Name.StartsWith ("add_") || mt.method.Name.StartsWith ("remove_"))
                            continue;
                        
                        NCC.FunKind fk = mt.method.GetFunKind ();
                        if (fk is NCC.FunKind.Constructor || fk is NCC.FunKind.StaticConstructor)
                            methods.Add (new Constructor (this, mt.method));
                        else
                            methods.Add (new Method (this, mt.method));
                    }
                    else if (m is NCC.MemberKind.Property)
                    {
                        NCC.MemberKind.Property px = (NCC.MemberKind.Property)m;
                        if (px.prop.IsIndexer)
                            indexer.Add (new Indexer (this, px.prop));
                        else
                            properties.Add (new Property (this, px.prop));
                    }
                    else if (m is NCC.MemberKind.Event)
                        events.Add (new Event (this, ((NCC.MemberKind.Event)m).body));
                    else if (m is NCC.MemberKind.Type)
                        innerClasses.Add (new Class ( ((NCC.MemberKind.Type)m).tycon, cu));
                }
            }
            
            foreach (NCC.MType.Class mt in tinfo.GetDirectSuperTypes ())
            {
                if (mt.tycon.FrameworkTypeName != "System.Object" &&
                    mt.tycon.FrameworkTypeName != "System.ValueType" &&
                    mt.tycon.FrameworkTypeName != "System.Enum" &&
                    mt.tycon.FrameworkTypeName != "System.Delegate" &&
                    mt.tycon.FrameworkTypeName != "System.MulticastDelegate")
                    baseTypes.Add (new ReturnType(mt));
            }
            
            LoadXml ();
        }
Exemple #36
0
 public Class(NCC.TypeInfo tinfo, DefaultCompilationUnit cu)
   : this (tinfo, cu, true)
 { }
Exemple #37
0
 public Class(string name, DefaultCompilationUnit cu): base (cu)
 {
     this.FullyQualifiedName = name;
     this.modifiers = (ModifierEnum)0;
 }
Exemple #38
0
 public Class(System.Type tinfo, DefaultCompilationUnit cu): base (cu)
 {
     this.tinfo = null;
     this.FullyQualifiedName = tinfo.FullName.TrimEnd('*');
     if (this.FullyQualifiedName.Contains("`"))
         this.FullyQualifiedName = this.FullyQualifiedName.TrimEnd ('1', '2', '3', '4').TrimEnd('`');
     
     if (tinfo.IsEnum)
         classType = ClassType.Enum;
     else if (tinfo.IsInterface)
         classType = ClassType.Interface;
     else if (tinfo.IsValueType)
         classType = ClassType.Struct;
     else if (tinfo.IsSubclassOf(typeof(System.Delegate)) ||
         tinfo.IsSubclassOf(typeof(System.MulticastDelegate)))
         classType = ClassType.Delegate;
     else
         classType = ClassType.Class;
         
     this.region = GetRegion ();
     this.bodyRegion = GetRegion ();
     
     ModifierEnum mod = (ModifierEnum)0;
     if (tinfo.IsNotPublic)
         mod |= ModifierEnum.Private;
     if (tinfo.IsPublic)
         mod |= ModifierEnum.Public;
     if (tinfo.IsAbstract)
         mod |= ModifierEnum.Abstract;
     if (tinfo.IsSealed)
         mod |= ModifierEnum.Sealed;
     
     modifiers = mod;
     
     if (tinfo.IsEnum)
     {
         foreach (SR.FieldInfo field in tinfo.GetFields())
         {
             if (field.Name != "value__" && !field.Name.StartsWith("_N"))
                 fields.Add (new Field (this, field));
         }
     }
     else
     {
         foreach (SR.FieldInfo field in tinfo.GetFields())
         {
             if (!field.Name.StartsWith("_N"))
                 fields.Add (new Field (this, field));
         }
     }
     foreach (SR.MethodInfo method in tinfo.GetMethods())
     {
         if (method.Name.StartsWith("_N") || method.Name.StartsWith("get_") || method.Name.StartsWith("set_") ||
             method.Name.StartsWith("add_") || method.Name.StartsWith("remove_"))
             continue;
         if (method.IsConstructor)
             continue; //methods.Add (new Constructor (this, method));
         else
             methods.Add (new Method (this, method));
     }
     foreach (SR.PropertyInfo prop in tinfo.GetProperties())
     {
         properties.Add (new Property (this, prop));
     }
     foreach (SR.EventInfo ev in tinfo.GetEvents())
     {
         events.Add (new Event (this, ev));
     }
     
     foreach (System.Type i in tinfo.GetNestedTypes())
     {
         Class nested = new Class (i, cu);
         innerClasses.Add (nested);
     }
     
     LoadXml ();
 }
Exemple #39
0
        ResolveResult GetResults (NCC.CompletionResult results, DefaultCompilationUnit cu, bool completeLocals)
        {
            try
            {
            if (results == null || results.Elems.Count == 0)
                return null;
                        
            if (results.Elems [0] is NCC.Elem.Node)
            {
                List<string> alreadyAdded = new List<string> ();
                List<string> namespaces = new List<string> ();
                LanguageItemCollection lang = new LanguageItemCollection ();
                
                foreach (NCC.Elem elem in results.Elems)
                {
                    if (!(elem is NCC.Elem.Node))
                        continue;
                    
                    NCC.Elem.Node enode = (NCC.Elem.Node)elem;
                    if (enode.node.Value is NCC.NamespaceTree.TypeInfoCache.NamespaceReference)
                    {
                        namespaces.Add (enode.Name);
                    }
                    else if (enode.node.Value is NCC.NamespaceTree.TypeInfoCache.Cached)
                    {
                        if (!alreadyAdded.Contains (enode.Name))
                        {
                            alreadyAdded.Add (enode.Name);
                            lang.Add (new Class (((NCC.NamespaceTree.TypeInfoCache.Cached)enode.node.Value).tycon, cu, false));
                        }
                    }
                }
                return new ResolveResult (namespaces.ToArray (), lang);
            }
            else
            {
                Class declaring = GetTheRealType (results.ObjectType, cu);
                
                /*if (declaring.FullyQualifiedName == "System.Object")
                {
                    // Try with any other member
                    NCC.TypeInfo found = null;
                    foreach (NCC.OverloadPossibility ov in results.Overloads)
                    {
                        if (ov.Member.DeclaringType.FrameworkTypeName != "System.Object")
                        {
                            found = ov.Member.DeclaringType;
                            break;
                        }
                    }
                    if (found != null)
                        declaring = new Class (found, cu, false);
                }*/
                
                LanguageItemCollection lang = new LanguageItemCollection ();
                
                foreach (NCC.Elem elem in results.Elems)
                {
                    if (elem is NCC.Elem.Local)
                    {
                        if (!completeLocals)
                            continue;
                        
                        NCC.Elem.Local lvalue = (NCC.Elem.Local)elem;
/*                        lang.Add (new NemerleBinding.Parser.SharpDevelopTree.Local 
                            (new Class ("LOCALS", cu), lvalue.Value));
*/                    }
                    else if (elem is NCC.Elem.Overloads)
                    {
                        NCC.Elem.Overloads lvalue = (NCC.Elem.Overloads)elem;
                        foreach (NCC.OverloadPossibility ov in lvalue.Values)
                            AddMember (declaring, lang, ov.Member); 
                    }
                    else if (elem is NCC.Elem.Overload)
                    {
                        NCC.Elem.Overload lvalue = (NCC.Elem.Overload)elem;
                        AddMember (declaring, lang, lvalue.Value.Member);
                    }
                    else if (elem is NCC.Elem.Member)
                    {
                        NCC.Elem.Member lvalue = (NCC.Elem.Member)elem;
                        AddMember (declaring, lang, lvalue.member);
                    }
                }
                
                return new ResolveResult (declaring, lang);
            }
            }
            catch (Exception ex)
            {
                System.Console.WriteLine (ex.GetType().FullName);
                System.Console.WriteLine (ex.Message);
                System.Console.WriteLine (ex.StackTrace);
                if (ex.InnerException != null)
                {
                    System.Console.WriteLine (ex.InnerException.GetType().FullName);
                    System.Console.WriteLine (ex.InnerException.Message);
                    System.Console.WriteLine (ex.InnerException.StackTrace);
                }
                return null;
            }
        }
		public NRefactoryASTConvertVisitor(IProjectContent projectContent)
		{
			cu = new DefaultCompilationUnit(projectContent);
		}
 void CreateDefaultClass(string fullyQualifiedName)
 {
     projectContent = new DefaultProjectContent();
     compilationUnit = new DefaultCompilationUnit(projectContent);
     defaultClass = new DefaultClass(compilationUnit, fullyQualifiedName);
 }