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);
}
