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."); }
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)); }
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); }
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); }
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); }
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); }
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); }
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); }
/// <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); }
/// <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)); }
public PythonModuleCompletionItems(PythonStandardModuleType moduleType) { projectContent = new DefaultProjectContent(); compilationUnit = new DefaultCompilationUnit(projectContent); moduleClass = new DefaultClass(compilationUnit, moduleType.Name); AddCompletionItemsForType(moduleType.Type); AddStandardCompletionItems(); }
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); }
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()); }
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; } }
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 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 (); }
public Class(NCC.TypeInfo tinfo, DefaultCompilationUnit cu) : this (tinfo, cu, true) { }
public Class(string name, DefaultCompilationUnit cu): base (cu) { this.FullyQualifiedName = name; this.modifiers = (ModifierEnum)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 (); }
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); }