bool ReadClasses()
{
int classCount = reader.ReadInt32();
int externalTypeCount = reader.ReadInt32();
types = new IReturnType[classCount + externalTypeCount];
DefaultClass[] classes = new DefaultClass[classCount];
for (int i = 0; i < classes.Length; i++)
{
DefaultClass c = new DefaultClass(pc.AssemblyCompilationUnit, reader.ReadString());
classes[i] = c;
types[i] = c.DefaultReturnType;
}
for (int i = classCount; i < types.Length; i++)
{
string name = reader.ReadString();
types[i] = new GetClassReturnType(pc, name, reader.ReadByte());
}
stringArray = new string[reader.ReadInt32()];
for (int i = 0; i < stringArray.Length; i++)
{
stringArray[i] = reader.ReadString();
}
ReadAttributes(pc.AssemblyCompilationUnit);
for (int i = 0; i < classes.Length; i++)
{
ReadClass(classes[i]);
pc.AddClassToNamespaceList(classes[i]);
if (reader.ReadByte() != 64)
{
return(false);
}
}
return(true);
}
public static DefaultClass GetDummyClassForTypeParameter(ITypeParameter p)
{
DefaultClass c = new DefaultClass(p.Class.CompilationUnit, p.Name);
if (p.Method != null)
{
c.Region = new DomRegion(p.Method.Region.BeginLine, p.Method.Region.BeginColumn);
}
else
{
c.Region = new DomRegion(p.Class.Region.BeginLine, p.Class.Region.BeginColumn);
}
c.Modifiers = ModifierEnum.Public;
if (p.HasValueTypeConstraint)
{
c.ClassType = ClassType.Struct;
}
else if (p.HasConstructableConstraint)
{
c.ClassType = ClassType.Class;
}
else
{
c.ClassType = ClassType.Interface;
}
return(c);
}
static IClass CreateMyApplication(ICompilationUnit cu, VBNetProject project, string ns)
{
DefaultClass c = new DefaultClass(cu, ns + ".MyApplication");
c.ClassType = ClassType.Class;
c.Modifiers = ModifierEnum.Internal | ModifierEnum.Sealed | ModifierEnum.Partial | ModifierEnum.Synthetic;
c.Attributes.Add(new DefaultAttribute(CreateTypeRef(cu, "Microsoft.VisualBasic.HideModuleNameAttribute")));
switch (project.OutputType) {
case OutputType.WinExe:
c.BaseTypes.Add(CreateTypeRef(cu, "Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase"));
if (project.GetEvaluatedProperty("MyType") == "WindowsForms") {
c.Methods.Add(
new DefaultMethod(c, "Main") {
Modifiers = ModifierEnum.Internal | ModifierEnum.Static,
ReturnType = c.ProjectContent.SystemTypes.Void,
Parameters = new[] {
new DefaultParameter(
"args",
new ArrayReturnType(c.ProjectContent, c.ProjectContent.SystemTypes.String, 1),
DomRegion.Empty
)
}
});
}
break;
case OutputType.Exe:
c.BaseTypes.Add(CreateTypeRef(cu, "Microsoft.VisualBasic.ApplicationServices.ConsoleApplicationBase"));
break;
default:
c.BaseTypes.Add(CreateTypeRef(cu, "Microsoft.VisualBasic.ApplicationServices.ApplicationBase"));
break;
}
return c;
}
void AddWebViewPageBaseClass(DefaultClass webViewPageClass, IReturnType modelType)
{
IClass webViewPageBaseClass = webViewPageClass.ProjectContent.GetClass("System.Web.Mvc.WebViewPage", 1);
if (webViewPageBaseClass != null) {
IReturnType returnType = GetWebViewPageBaseClassReturnType(webViewPageBaseClass, modelType);
webViewPageClass.BaseTypes.Add(returnType);
}
}
public override IClass GetUnderlyingClass()
{
if (cachedClass != null) return cachedClass;
DefaultClass c = new DefaultClass(cu, ClassType.Delegate, ModifierEnum.None, DomRegion.Empty, null);
c.BaseTypes.Add(cu.ProjectContent.SystemTypes.Delegate);
AddDefaultDelegateMethod(c, returnType ?? cu.ProjectContent.SystemTypes.Object, parameters);
cachedClass = c;
return c;
}
DefaultClass CreateWebViewPageClass(RazorCompilationUnit compilationUnit)
{
var webViewPageClass = new DefaultClass(compilationUnit, "RazorWebViewPage") {
Region = new DomRegion(1, 0, 3, 0)
};
IReturnType modelType = GetModelReturnType(compilationUnit);
AddWebViewPageBaseClass(webViewPageClass, modelType);
return webViewPageClass;
}
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));
}
protected override ExpressionResult GetExpressionResult()
{
List<ICompletionEntry> namespaceItems = new List<ICompletionEntry>();
DefaultClass consoleClass = new DefaultClass(compilationUnit, "System.Console");
namespaceItems.Add(consoleClass);
projectContent.AddExistingNamespaceContents("System", namespaceItems);
return new ExpressionResult("MySystem", ExpressionContext.Default);
}
public void FindMethodFromArrayReturnsNullForUnknownMethod()
{
DefaultClass c = new DefaultClass(new DefaultCompilationUnit(new DefaultProjectContent()), "Test");
DefaultMethod method = new DefaultMethod(c, "abc");
ArrayList items = new ArrayList();
items.Add(method);
Assert.IsNull(PythonCompletionItemsHelper.FindMethodFromCollection("unknown", items));
}
public IClass GetInnermostClass(int caretLine, int caretColumn)
{
foreach (IClass c in Classes)
{
if (c != null && DefaultClass.IsInside(c, caretLine, caretColumn))
{
return(c.GetInnermostClass(caretLine, caretColumn));
}
}
return(null);
}
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 override IClass GetUnderlyingClass()
{
if (cachedClass != null)
{
return(cachedClass);
}
DefaultClass c = new DefaultClass(cu, ClassType.Delegate, ModifierEnum.None, DomRegion.Empty, null);
c.BaseTypes.Add(cu.ProjectContent.SystemTypes.Delegate);
AddDefaultDelegateMethod(c, returnType ?? cu.ProjectContent.SystemTypes.Object, parameters ?? new IParameter[0]);
cachedClass = c;
return(c);
}
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);
}
/// <summary>
/// Builds Visual Basic's "My" namespace for the specified project.
/// </summary>
public static void BuildNamespace(VBNetProject project, IProjectContent pc)
{
if ("custom".Equals(project.GetEvaluatedProperty("MyType"), StringComparison.OrdinalIgnoreCase))
return;
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, ns);
cu.Classes.Add(myApp);
cu.Classes.Add(myComp);
IClass myForms = null;
if (project.OutputType == OutputType.WinExe) {
myForms = CreateMyForms(cu, 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 FixtureSetup()
{
ProjectContentRegistry r = new ProjectContentRegistry();
msc = r.Mscorlib;
swf = r.GetProjectContentForReference("System.Windows.Forms", typeof(System.Windows.Forms.Form).Module.FullyQualifiedName);
DefaultProjectContent dpc = new DefaultProjectContent();
dpc.ReferencedContents.Add(msc);
DefaultCompilationUnit cu = new DefaultCompilationUnit(dpc);
dummyClass = new DefaultClass(cu, "DummyClass");
cu.Classes.Add(dummyClass);
methodForGenericCalls = new DefaultMethod(dummyClass, "DummyMethod");
dummyClass.Methods.Add(methodForGenericCalls);
}
DefaultClass AddClass(NavigateToItem item, IDocument document)
{
var defaultClass = new DefaultClass(this, item.GetFullName());
defaultClass.BodyRegion = item.ToRegion(document);
defaultClass.Region = defaultClass.BodyRegion;
if (item.HasContainer()) {
IClass parentClass = FindParentClass(item);
parentClass.InnerClasses.Add(defaultClass);
} else {
Classes.Add(defaultClass);
}
return defaultClass;
}
public void Init()
{
DefaultProjectContent projectContent = new DefaultProjectContent();
unit = new DefaultCompilationUnit(projectContent);
DefaultClass c = new DefaultClass(unit, "Foo");
DefaultMethod buttonClickMethod = new DefaultMethod(c, "ButtonClick");
AddSenderAndEventArgsParameters(buttonClickMethod);
c.Methods.Add(buttonClickMethod);
projectContent.AddClassToNamespaceList(c);
parseInfo = new ParseInformation(unit);
}
static void AddTypeParametersForCtrlSpace(ArrayList result, IEnumerable <ITypeParameter> typeParameters)
{
foreach (ITypeParameter p in typeParameters)
{
DefaultClass c = DefaultTypeParameter.GetDummyClassForTypeParameter(p);
if (p.Method != null)
{
c.Documentation = "Type parameter of " + p.Method.Name;
}
else
{
c.Documentation = "Type parameter of " + p.Class.Name;
}
result.Add(c);
}
}
/// <summary>
/// Walks a class definition.
/// </summary>
public override bool Walk(ClassDefinition node)
{
DefaultClass c = new DefaultClass(compilationUnit, GetFullyQualifiedClassName(node));
c.Region = GetRegion(node);
c.BodyRegion = GetBodyRegion(node.Body, node.Header);
AddBaseTypes(c, node.Bases);
// Save the class.
compilationUnit.Classes.Add(c);
// Walk through all the class items.
currentClass = c;
node.Body.Walk(this);
currentClass = null;
return false;
}
internal static void AddDefaultDelegateMethod(DefaultClass c, IReturnType returnType, IList<IParameter> parameters)
{
ModifierEnum modifiers = ModifierEnum.Public | ModifierEnum.Synthetic;
DefaultMethod invokeMethod = new DefaultMethod("Invoke", returnType, modifiers, c.Region, DomRegion.Empty, c);
foreach (IParameter par in parameters) {
invokeMethod.Parameters.Add(par);
}
c.Methods.Add(invokeMethod);
invokeMethod = new DefaultMethod("BeginInvoke", c.ProjectContent.SystemTypes.IAsyncResult, modifiers, c.Region, DomRegion.Empty, c);
foreach (IParameter par in parameters) {
invokeMethod.Parameters.Add(par);
}
invokeMethod.Parameters.Add(new DefaultParameter("callback", c.ProjectContent.SystemTypes.AsyncCallback, DomRegion.Empty));
invokeMethod.Parameters.Add(new DefaultParameter("object", c.ProjectContent.SystemTypes.Object, DomRegion.Empty));
c.Methods.Add(invokeMethod);
invokeMethod = new DefaultMethod("EndInvoke", returnType, modifiers, c.Region, DomRegion.Empty, c);
invokeMethod.Parameters.Add(new DefaultParameter("result", c.ProjectContent.SystemTypes.IAsyncResult, DomRegion.Empty));
c.Methods.Add(invokeMethod);
}
internal static void AddDefaultDelegateMethod(DefaultClass c, IReturnType returnType, IList <IParameter> parameters)
{
ModifierEnum modifiers = ModifierEnum.Public | ModifierEnum.Synthetic;
DefaultMethod invokeMethod = new DefaultMethod("Invoke", returnType, modifiers, c.Region, DomRegion.Empty, c);
foreach (IParameter par in parameters)
{
invokeMethod.Parameters.Add(par);
}
c.Methods.Add(invokeMethod);
invokeMethod = new DefaultMethod("BeginInvoke", c.ProjectContent.SystemTypes.IAsyncResult, modifiers, c.Region, DomRegion.Empty, c);
foreach (IParameter par in parameters)
{
invokeMethod.Parameters.Add(par);
}
invokeMethod.Parameters.Add(new DefaultParameter("callback", c.ProjectContent.SystemTypes.AsyncCallback, DomRegion.Empty));
invokeMethod.Parameters.Add(new DefaultParameter("object", c.ProjectContent.SystemTypes.Object, DomRegion.Empty));
c.Methods.Add(invokeMethod);
invokeMethod = new DefaultMethod("EndInvoke", returnType, modifiers, c.Region, DomRegion.Empty, c);
invokeMethod.Parameters.Add(new DefaultParameter("result", c.ProjectContent.SystemTypes.IAsyncResult, DomRegion.Empty));
c.Methods.Add(invokeMethod);
}
public override object VisitEventDeclaration(NRefactoryAST.EventDeclaration eventDeclaration, object data)
{
DomRegion region = GetRegion(eventDeclaration.StartLocation, eventDeclaration.EndLocation);
DomRegion bodyRegion = GetRegion(eventDeclaration.BodyStart, eventDeclaration.BodyEnd);
DefaultClass c = GetCurrentClass();
IReturnType type;
if (eventDeclaration.TypeReference.IsNull) {
DefaultClass del = new DefaultClass(cu, ClassType.Delegate,
ConvertModifier(eventDeclaration.Modifier),
region, c);
del.Modifiers |= ModifierEnum.Synthetic;
CreateDelegate(del, eventDeclaration.Name + "EventHandler",
new NRefactoryAST.TypeReference("System.Void", true),
new NRefactoryAST.TemplateDefinition[0],
eventDeclaration.Parameters);
type = del.DefaultReturnType;
} else {
type = CreateReturnType(eventDeclaration.TypeReference);
}
DefaultEvent e = new DefaultEvent(eventDeclaration.Name, type, ConvertModifier(eventDeclaration.Modifier), region, bodyRegion, c);
ConvertAttributes(eventDeclaration, e);
c.Events.Add(e);
e.Documentation = GetDocumentation(region.BeginLine, eventDeclaration.Attributes);
if (eventDeclaration.HasAddRegion) {
e.AddMethod = new DefaultMethod(e.DeclaringType, "add_" + e.Name) {
Parameters = { new DefaultParameter("value", e.ReturnType, DomRegion.Empty) },
Region = GetRegion(eventDeclaration.AddRegion.StartLocation, eventDeclaration.AddRegion.EndLocation),
BodyRegion = GetRegion(eventDeclaration.AddRegion.Block.StartLocation, eventDeclaration.AddRegion.Block.EndLocation)
};
}
if (eventDeclaration.HasRemoveRegion) {
e.RemoveMethod = new DefaultMethod(e.DeclaringType, "remove_" + e.Name) {
Parameters = { new DefaultParameter("value", e.ReturnType, DomRegion.Empty) },
Region = GetRegion(eventDeclaration.RemoveRegion.StartLocation, eventDeclaration.RemoveRegion.EndLocation),
BodyRegion = GetRegion(eventDeclaration.RemoveRegion.Block.StartLocation, eventDeclaration.RemoveRegion.Block.EndLocation)
};
}
return null;
}
void CreateDelegate(DefaultClass c, string name, NRefactoryAST.TypeReference returnType, IList<NRefactoryAST.TemplateDefinition> templates, IList<NRefactoryAST.ParameterDeclarationExpression> parameters)
{
c.BaseTypes.Add(c.ProjectContent.SystemTypes.MulticastDelegate);
DefaultClass outerClass = GetCurrentClass();
if (outerClass != null) {
outerClass.InnerClasses.Add(c);
c.FullyQualifiedName = outerClass.FullyQualifiedName + '.' + name;
} else {
c.FullyQualifiedName = PrependCurrentNamespace(name);
cu.Classes.Add(c);
}
c.UsingScope = currentNamespace;
currentClass.Push(c); // necessary for CreateReturnType
ConvertTemplates(outerClass, templates, c);
List<IParameter> p = new List<IParameter>();
if (parameters != null) {
foreach (NRefactoryAST.ParameterDeclarationExpression param in parameters) {
p.Add(CreateParameter(param));
}
}
AnonymousMethodReturnType.AddDefaultDelegateMethod(c, CreateReturnType(returnType), p);
currentClass.Pop();
}
public override object VisitDelegateDeclaration(NRefactoryAST.DelegateDeclaration delegateDeclaration, object data)
{
DomRegion region = GetRegion(delegateDeclaration.StartLocation, delegateDeclaration.EndLocation);
DefaultClass c = new DefaultClass(cu, ClassType.Delegate, ConvertTypeModifier(delegateDeclaration.Modifier), region, GetCurrentClass());
c.Documentation = GetDocumentation(region.BeginLine, delegateDeclaration.Attributes);
ConvertAttributes(delegateDeclaration, c);
CreateDelegate(c, delegateDeclaration.Name, delegateDeclaration.ReturnType,
delegateDeclaration.Templates, delegateDeclaration.Parameters);
return c;
}
void ConvertTemplates(DefaultClass outerClass, IList<NRefactoryAST.TemplateDefinition> templateList, DefaultClass c)
{
int outerClassTypeParameterCount = outerClass != null ? outerClass.TypeParameters.Count : 0;
if (templateList.Count == 0 && outerClassTypeParameterCount == 0) {
c.TypeParameters = DefaultTypeParameter.EmptyTypeParameterList;
} else {
Debug.Assert(c.TypeParameters.Count == 0);
int index = 0;
if (outerClassTypeParameterCount > 0) {
foreach (DefaultTypeParameter outerTypeParamter in outerClass.TypeParameters) {
DefaultTypeParameter p = new DefaultTypeParameter(c, outerTypeParamter.Name, index++);
p.HasConstructableConstraint = outerTypeParamter.HasConstructableConstraint;
p.HasReferenceTypeConstraint = outerTypeParamter.HasReferenceTypeConstraint;
p.HasValueTypeConstraint = outerTypeParamter.HasValueTypeConstraint;
p.Attributes.AddRange(outerTypeParamter.Attributes);
p.Constraints.AddRange(outerTypeParamter.Constraints);
c.TypeParameters.Add(p);
}
}
foreach (NRefactoryAST.TemplateDefinition template in templateList) {
c.TypeParameters.Add(new DefaultTypeParameter(c, template.Name, index++));
}
// converting the constraints requires that the type parameters are already present
for (int i = 0; i < templateList.Count; i++) {
ConvertConstraints(templateList[i], (DefaultTypeParameter)c.TypeParameters[i + outerClassTypeParameterCount]);
}
}
}
public override object VisitTypeDeclaration(NRefactoryAST.TypeDeclaration typeDeclaration, object data)
{
DomRegion region = GetRegion(typeDeclaration.StartLocation, typeDeclaration.EndLocation);
DomRegion bodyRegion = GetRegion(typeDeclaration.BodyStartLocation, typeDeclaration.EndLocation);
DefaultClass c = new DefaultClass(cu, TranslateClassType(typeDeclaration.Type), ConvertTypeModifier(typeDeclaration.Modifier), region, GetCurrentClass());
if (c.IsStatic) {
// static classes are also abstract and sealed at the same time
c.Modifiers |= ModifierEnum.Abstract | ModifierEnum.Sealed;
}
c.BodyRegion = bodyRegion;
ConvertAttributes(typeDeclaration, c);
c.Documentation = GetDocumentation(region.BeginLine, typeDeclaration.Attributes);
DefaultClass outerClass = GetCurrentClass();
if (outerClass != null) {
outerClass.InnerClasses.Add(c);
c.FullyQualifiedName = outerClass.FullyQualifiedName + '.' + typeDeclaration.Name;
} else {
c.FullyQualifiedName = PrependCurrentNamespace(typeDeclaration.Name);
cu.Classes.Add(c);
}
c.UsingScope = currentNamespace;
currentClass.Push(c);
ConvertTemplates(outerClass, typeDeclaration.Templates, c); // resolve constrains in context of the class
// templates must be converted before base types because base types may refer to generic types
if (c.ClassType != ClassType.Enum && typeDeclaration.BaseTypes != null) {
foreach (NRefactoryAST.TypeReference type in typeDeclaration.BaseTypes) {
IReturnType rt = CreateReturnType(type, null, TypeVisitor.ReturnTypeOptions.BaseTypeReference);
if (rt != null) {
c.BaseTypes.Add(rt);
}
}
}
object ret = typeDeclaration.AcceptChildren(this, data);
currentClass.Pop();
if (c.ClassType == ClassType.Module) {
foreach (DefaultField f in c.Fields) {
f.Modifiers |= ModifierEnum.Static;
}
foreach (DefaultMethod m in c.Methods) {
m.Modifiers |= ModifierEnum.Static;
}
foreach (DefaultProperty p in c.Properties) {
p.Modifiers |= ModifierEnum.Static;
}
foreach (DefaultEvent e in c.Events) {
e.Modifiers |= ModifierEnum.Static;
}
}
mapType(typeDeclaration, c);
return ret;
}
public ICompilationUnit Parse(IProjectContent projectContent, string fileName, ITextBuffer fileContent)
{
Init(fileContent.Text);
SimpleCocoParser parser = new SimpleCocoParser(new Scanner(new StringStream(fileContent.Text)));
parser.Parse();
DefaultCompilationUnit cu = new DefaultCompilationUnit(projectContent);
Location start, end;
if (parser.CopySection != null) {
start = OffsetToLocation(parser.CopySection.StartOffset);
end = OffsetToLocation(parser.CopySection.EndOffset);
cu.FoldingRegions.Add(new FoldingRegion("[copy]", new DomRegion(start.Line, start.Column, end.Line, end.Column)));
}
if (parser.UsingSection != null) {
start = OffsetToLocation(parser.UsingSection.StartOffset);
end = OffsetToLocation(parser.UsingSection.EndOffset);
cu.FoldingRegions.Add(new FoldingRegion("[...]", new DomRegion(start.Line, start.Column, end.Line, end.Column)));
}
DefaultClass parserClass = null;
if (parser.ParserSection != null) {
start = OffsetToLocation(parser.ParserSection.StartOffset);
end = OffsetToLocation(parser.ParserSection.EndOffset);
parserClass = new DefaultClass(cu, parser.ParserName);
parserClass.ClassType = ClassType.Class;
parserClass.Modifiers = ModifierEnum.None;
parserClass.Region = new DomRegion(start.Line, start.Column, end.Line, end.Column);
cu.Classes.Add(parserClass);
foreach (var info in parser.Lists) {
start = OffsetToLocation(info.segment.StartOffset);
end = OffsetToLocation(info.segment.EndOffset);
var region = new DomRegion(start.Line, start.Column, start.Line, start.Column + info.name.Length);
var body = new DomRegion(start.Line, start.Column, end.Line, end.Column);
var prop = new DefaultProperty(parserClass, info.name) {
Region = region, BodyRegion = body, Modifiers = ModifierEnum.Public
};
parserClass.Properties.Add(prop);
}
foreach (var info in parser.Productions) {
start = OffsetToLocation(info.segment.StartOffset);
end = OffsetToLocation(info.segment.EndOffset);
var region = new DomRegion(start.Line, start.Column, start.Line, start.Column + info.name.Length);
var body = new DomRegion(start.Line, start.Column, end.Line, end.Column);
var method = new DefaultMethod(parserClass, info.name) {
Region = region, BodyRegion = body, Modifiers = ModifierEnum.Public
};
parserClass.Methods.Add(method);
}
}
return cu;
}
private void EnterTypeDefinition(AST.TypeDefinition node, ClassType classType)
{
//LoggingService.Debug("Enter " + node.GetType().Name + " (" + node.FullName + ")");
foreach (AST.Attribute att in node.Attributes) {
if (att.Name == "Boo.Lang.ModuleAttribute")
classType = ClassType.Module;
}
DomRegion region = GetClientRegion(node);
DefaultClass c = new DefaultClass(_cu, classType, GetModifier(node), region, OuterClass);
c.FullyQualifiedName = node.FullName;
if (_currentClass.Count > 0)
_currentClass.Peek().InnerClasses.Add(c);
else
_cu.Classes.Add(c);
_currentClass.Push(c);
ConvertAttributes(node, c);
ConvertTemplates(node, c);
if (node.BaseTypes != null) {
foreach (AST.TypeReference r in node.BaseTypes) {
c.BaseTypes.Add(CreateReturnType(r));
}
}
}
bool ReadClasses()
{
int classCount = reader.ReadInt32();
int externalTypeCount = reader.ReadInt32();
types = new IReturnType[classCount + externalTypeCount];
DefaultClass[] classes = new DefaultClass[classCount];
for (int i = 0; i < classes.Length; i++) {
DefaultClass c = new DefaultClass(pc.AssemblyCompilationUnit, reader.ReadString());
classes[i] = c;
types[i] = c.DefaultReturnType;
}
for (int i = classCount; i < types.Length; i++) {
string name = reader.ReadString();
types[i] = new GetClassReturnType(pc, name, reader.ReadByte());
}
stringArray = new string[reader.ReadInt32()];
for (int i = 0; i < stringArray.Length; i++) {
stringArray[i] = reader.ReadString();
}
ReadAttributes(pc.AssemblyCompilationUnit);
for (int i = 0; i < classes.Length; i++) {
ReadClass(classes[i]);
pc.AddClassToNamespaceList(classes[i]);
if (reader.ReadByte() != 64) {
return false;
}
}
return true;
}
void ReadClass(DefaultClass c)
{
this.currentClass = c;
int count;
count = reader.ReadByte();
for (int i = 0; i < count; i++)
{
c.TypeParameters.Add(new DefaultTypeParameter(c, ReadString(), i));
}
if (count > 0)
{
foreach (ITypeParameter typeParameter in c.TypeParameters)
{
count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
typeParameter.Constraints.Add(ReadType());
}
}
}
else
{
c.TypeParameters = DefaultTypeParameter.EmptyTypeParameterList;
}
count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
c.BaseTypes.Add(ReadType());
}
c.Modifiers = (ModifierEnum)reader.ReadInt32();
c.CalculatedFlags = reader.ReadByte();
c.ClassType = (ClassType)reader.ReadByte();
ReadAttributes(c);
count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
DefaultClass innerClass = new DefaultClass(c.CompilationUnit, c);
innerClass.FullyQualifiedName = reader.ReadString();
c.InnerClasses.Add(innerClass);
ReadClass(innerClass);
}
this.currentClass = c;
count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
c.Methods.Add(ReadMethod());
}
count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
c.Properties.Add(ReadProperty());
}
count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
c.Events.Add(ReadEvent());
}
count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
c.Fields.Add(ReadField());
}
this.currentClass = null;
}
/// <summary>
/// Gets all types the specified type inherits from (all classes and interfaces).
/// Unlike the class inheritance tree, this method takes care of type arguments and calculates the type
/// arguments that are passed to base classes.
/// </summary>
public static IEnumerable <IReturnType> GetTypeInheritanceTree(IReturnType typeToListInheritanceTreeFor)
{
if (typeToListInheritanceTreeFor == null)
{
throw new ArgumentNullException("typeToListInheritanceTreeFor");
}
lock (getTypeInheritanceTreeCache) {
IEnumerable <IReturnType> result;
if (getTypeInheritanceTreeCache.TryGetValue(typeToListInheritanceTreeFor, out result))
{
return(result);
}
}
IClass classToListInheritanceTreeFor = typeToListInheritanceTreeFor.GetUnderlyingClass();
if (classToListInheritanceTreeFor == null)
{
return new IReturnType[] { typeToListInheritanceTreeFor }
}
;
if (typeToListInheritanceTreeFor.IsArrayReturnType)
{
IReturnType elementType = typeToListInheritanceTreeFor.CastToArrayReturnType().ArrayElementType;
List <IReturnType> resultList = new List <IReturnType>();
resultList.Add(typeToListInheritanceTreeFor);
resultList.AddRange(GetTypeInheritanceTree(
new ConstructedReturnType(
classToListInheritanceTreeFor.ProjectContent.GetClass("System.Collections.Generic.IList", 1).DefaultReturnType,
new IReturnType[] { elementType }
)
));
resultList.Add(classToListInheritanceTreeFor.ProjectContent.GetClass("System.Collections.IList", 0).DefaultReturnType);
resultList.Add(classToListInheritanceTreeFor.ProjectContent.GetClass("System.Collections.ICollection", 0).DefaultReturnType);
// non-generic IEnumerable is already added by generic IEnumerable
return(resultList);
}
HashSet <IReturnType> visitedSet = new HashSet <IReturnType>();
List <IReturnType> visitedList = new List <IReturnType>();
Queue <IReturnType> typesToVisit = new Queue <IReturnType>();
bool enqueuedLastBaseType = false;
IReturnType currentType = typeToListInheritanceTreeFor;
IClass currentClass = classToListInheritanceTreeFor;
IReturnType nextType;
do
{
if (currentClass != null)
{
if (visitedSet.Add(currentType))
{
visitedList.Add(currentType);
foreach (IReturnType type in currentClass.BaseTypes)
{
typesToVisit.Enqueue(TranslateIfRequired(currentType, type));
}
}
}
if (typesToVisit.Count > 0)
{
nextType = typesToVisit.Dequeue();
}
else
{
nextType = enqueuedLastBaseType ? null : DefaultClass.GetBaseTypeByClassType(classToListInheritanceTreeFor);
enqueuedLastBaseType = true;
}
if (nextType != null)
{
currentType = nextType;
currentClass = nextType.GetUnderlyingClass();
}
} while (nextType != null);
lock (getTypeInheritanceTreeCache) {
if (getTypeInheritanceTreeCache.Count == 0)
{
DomCache.RegisterForClear(ClearGetTypeInheritanceTreeCache);
}
getTypeInheritanceTreeCache[typeToListInheritanceTreeFor] = visitedList;
}
return(visitedList);
}
void ConvertTemplates(AST.Node node, DefaultClass c)
{
c.TypeParameters = DefaultTypeParameter.EmptyTypeParameterList;
}
public override void OnCallableDefinition(AST.CallableDefinition node)
{
LoggingService.Debug("OnCallableDefinition: " + node.FullName);
DomRegion region = GetRegion(node);
DefaultClass c = new DefaultClass(_cu, ClassType.Delegate, GetModifier(node), region, OuterClass);
ConvertAttributes(node, c);
c.BaseTypes.Add(c.ProjectContent.SystemTypes.Delegate);
c.FullyQualifiedName = node.FullName;
if (_currentClass.Count > 0) {
OuterClass.InnerClasses.Add(c);
} else {
_cu.Classes.Add(c);
}
_currentClass.Push(c); // necessary for CreateReturnType
ConvertTemplates(node, c);
IReturnType returnType = CreateReturnType(node.ReturnType);
DefaultMethod invokeMethod = new DefaultMethod("Invoke", returnType, ModifierEnum.Public, DomRegion.Empty, DomRegion.Empty, c);
ConvertParameters(node.Parameters, invokeMethod);
c.Methods.Add(invokeMethod);
invokeMethod = new DefaultMethod("BeginInvoke", c.ProjectContent.SystemTypes.IAsyncResult, ModifierEnum.Public, DomRegion.Empty, DomRegion.Empty, c);
ConvertParameters(node.Parameters, invokeMethod);
if (invokeMethod.Parameters == DefaultParameter.EmptyParameterList) {
invokeMethod.Parameters = new List<IParameter>();
}
invokeMethod.Parameters.Add(new DefaultParameter("callback", c.ProjectContent.SystemTypes.AsyncCallback, DomRegion.Empty));
invokeMethod.Parameters.Add(new DefaultParameter("object", c.ProjectContent.SystemTypes.Object, DomRegion.Empty));
c.Methods.Add(invokeMethod);
invokeMethod = new DefaultMethod("EndInvoke", returnType, ModifierEnum.Public, DomRegion.Empty, DomRegion.Empty, c);
invokeMethod.Parameters.Add(new DefaultParameter("result", c.ProjectContent.SystemTypes.IAsyncResult, DomRegion.Empty));
c.Methods.Add(invokeMethod);
_currentClass.Pop();
}
IClass AddClass(string className, AXmlElement element) {
if (projectContent.Language == LanguageProperties.VBNet && projectContent.Project is IProject)
className = ((IProject)projectContent.Project).RootNamespace + "." + className;
DefaultClass c = new DefaultClass(CompilationUnit, className);
string modifierValue = (element.GetAttributeValue(CompletionDataHelper.XamlNamespace, "ClassModifier") ?? string.Empty).Trim();
c.Modifiers = ModifierEnum.Partial;
string internalString = currentAmbience.ConvertAccessibility(ModifierEnum.Internal).Trim();
if (projectContent.Language.NameComparer.Compare(modifierValue, internalString) == 0)
c.Modifiers |= ModifierEnum.Internal;
else
c.Modifiers |= ModifierEnum.Public;
c.Region = CreateRegion(element.StartOffset, element.EndOffset);
var baseType = TypeFromXmlNode(CompilationUnit, element);
if (baseType != null)
c.BaseTypes.Add(baseType);
CompilationUnit.Classes.Add(c);
DefaultMethod initializeComponent = new DefaultMethod(
"InitializeComponent",
projectContent.SystemTypes.Void,
ModifierEnum.Public | ModifierEnum.Synthetic, c.Region, DomRegion.Empty,
c);
c.Methods.Add(initializeComponent);
return c;
}
static IClass CreateMyComputer(ICompilationUnit cu, string ns)
{
DefaultClass c = new DefaultClass(cu, ns + ".MyComputer");
c.ClassType = ClassType.Class;
c.Modifiers = ModifierEnum.Internal | ModifierEnum.Sealed | ModifierEnum.Partial | ModifierEnum.Synthetic;
c.Attributes.Add(new DefaultAttribute(CreateTypeRef(cu, "Microsoft.VisualBasic.HideModuleNameAttribute")));
c.BaseTypes.Add(CreateTypeRef(cu, "Microsoft.VisualBasic.Devices.Computer"));
return c;
}
void ReadClass(DefaultClass c)
{
this.currentClass = c;
int count;
count = reader.ReadByte();
for (int i = 0; i < count; i++) {
c.TypeParameters.Add(new DefaultTypeParameter(c, ReadString(), i));
}
if (count > 0) {
foreach (ITypeParameter typeParameter in c.TypeParameters) {
count = reader.ReadInt32();
for (int i = 0; i < count; i++) {
typeParameter.Constraints.Add(ReadType());
}
}
} else {
c.TypeParameters = DefaultTypeParameter.EmptyTypeParameterList;
}
count = reader.ReadInt32();
for (int i = 0; i < count; i++) {
c.BaseTypes.Add(ReadType());
}
c.Modifiers = (ModifierEnum)reader.ReadInt32();
c.CalculatedFlags = reader.ReadByte();
c.ClassType = (ClassType)reader.ReadByte();
ReadAttributes(c);
count = reader.ReadInt32();
for (int i = 0; i < count; i++) {
DefaultClass innerClass = new DefaultClass(c.CompilationUnit, c);
innerClass.FullyQualifiedName = reader.ReadString();
c.InnerClasses.Add(innerClass);
ReadClass(innerClass);
}
this.currentClass = c;
count = reader.ReadInt32();
for (int i = 0; i < count; i++) {
c.Methods.Add(ReadMethod());
}
count = reader.ReadInt32();
for (int i = 0; i < count; i++) {
c.Properties.Add(ReadProperty());
}
count = reader.ReadInt32();
for (int i = 0; i < count; i++) {
c.Events.Add(ReadEvent());
}
count = reader.ReadInt32();
for (int i = 0; i < count; i++) {
c.Fields.Add(ReadField());
}
this.currentClass = null;
}
static IClass GetPrimitiveClass(IProjectContent pc, string systemType, string newName)
{
IClass c = pc.GetClass(systemType, 0);
if (c == null) {
LoggingService.Warn("Could not find " + systemType);
return null;
}
DefaultClass c2 = new DefaultClass(c.CompilationUnit, newName);
c2.ClassType = c.ClassType;
c2.Modifiers = c.Modifiers;
c2.Documentation = c.Documentation;
c2.BaseTypes.AddRange(c.BaseTypes);
c2.Methods.AddRange(c.Methods);
c2.Fields.AddRange(c.Fields);
c2.Properties.AddRange(c.Properties);
c2.Events.AddRange(c.Events);
return c2;
}
public static DefaultClass GetDummyClassForTypeParameter(ITypeParameter p)
{
DefaultClass c = new DefaultClass(p.Class.CompilationUnit, p.Name);
if (p.Method != null) {
c.Region = new DomRegion(p.Method.Region.BeginLine, p.Method.Region.BeginColumn);
} else {
c.Region = new DomRegion(p.Class.Region.BeginLine, p.Class.Region.BeginColumn);
}
c.Modifiers = ModifierEnum.Public;
if (p.HasValueTypeConstraint) {
c.ClassType = ClassType.Struct;
} else if (p.HasConstructableConstraint) {
c.ClassType = ClassType.Class;
} else {
c.ClassType = ClassType.Interface;
}
return c;
}