DefaultUnresolvedMethod ConvertAccessor(Accessor accessor, IUnresolvedMember p, string prefix)
{
if (accessor.IsNull)
return null;
var a = new DefaultUnresolvedMethod(currentTypeDefinition, prefix + p.Name);
a.Accessibility = GetAccessibility(accessor.Modifiers) ?? p.Accessibility;
a.Region = MakeRegion(accessor);
if (p.EntityType == EntityType.Indexer) {
foreach (var indexerParam in ((IUnresolvedProperty)p).Parameters)
a.Parameters.Add(indexerParam);
}
DefaultUnresolvedParameter param = null;
if (accessor.Role == PropertyDeclaration.GetterRole) {
a.ReturnType = p.ReturnType;
} else {
param = new DefaultUnresolvedParameter(p.ReturnType, "value");
a.Parameters.Add(param);
a.ReturnType = KnownTypeReference.Void;
}
foreach (AttributeSection section in accessor.Attributes) {
if (section.AttributeTarget == "return") {
ConvertAttributes(a.ReturnTypeAttributes, section);
} else if (param != null && section.AttributeTarget == "param") {
ConvertAttributes(param.Attributes, section);
} else {
ConvertAttributes(a.Attributes, section);
}
}
return a;
}
void AddMethod(TypeScriptUnresolvedTypeDefinition parent, NavigationBarItem item, IDocument document)
{
var method = new DefaultUnresolvedMethod(parent, item.text);
UpdateMethodRegions(method, item, document);
parent.Members.Add(method);
}
public override IUnresolvedEntity VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data)
{
Modifiers modifiers = constructorDeclaration.Modifiers;
bool isStatic = (modifiers & Modifiers.Static) != 0;
DefaultUnresolvedMethod ctor = new DefaultUnresolvedMethod(currentTypeDefinition, isStatic ? ".cctor" : ".ctor");
ctor.EntityType = EntityType.Constructor;
ctor.Region = MakeRegion(constructorDeclaration);
if (!constructorDeclaration.Initializer.IsNull) {
ctor.BodyRegion = MakeRegion(constructorDeclaration.Initializer.StartLocation, constructorDeclaration.EndLocation);
} else {
ctor.BodyRegion = MakeRegion(constructorDeclaration.Body);
}
ctor.ReturnType = KnownTypeReference.Void;
ConvertAttributes(ctor.Attributes, constructorDeclaration.Attributes);
ConvertParameters(ctor.Parameters, constructorDeclaration.Parameters);
if (isStatic)
ctor.IsStatic = true;
else
ApplyModifiers(ctor, modifiers);
currentTypeDefinition.Members.Add(ctor);
if (interningProvider != null) {
ctor.ApplyInterningProvider(interningProvider);
}
return ctor;
}
DefaultUnresolvedMethod MakeUnresolvedMethod(params object[] parameterTypesOrDefaultValues)
{
var m = new DefaultUnresolvedMethod();
m.Name = "Method";
foreach (var typeOrDefaultValue in parameterTypesOrDefaultValues)
{
Type type = typeOrDefaultValue as Type;
if (type != null)
{
m.Parameters.Add(new DefaultUnresolvedParameter(type.ToTypeReference(), string.Empty));
}
else if (Type.GetTypeCode(typeOrDefaultValue.GetType()) > TypeCode.Object)
{
m.Parameters.Add(new DefaultUnresolvedParameter(typeOrDefaultValue.GetType().ToTypeReference(), string.Empty)
{
DefaultValue = new SimpleConstantValue(typeOrDefaultValue.GetType().ToTypeReference(), typeOrDefaultValue)
});
}
else
{
throw new ArgumentException(typeOrDefaultValue.ToString());
}
}
return(m);
}
static IUnresolvedMethod FunctionToIMethod(ProjectInformation pi, IUnresolvedTypeDefinition type, Function function, string[] contentLines)
{
var method = new DefaultUnresolvedMethod(type, function.Name);
method.Region = new DomRegion((int)function.Line, 1, FindFunctionEnd(contentLines, (int)function.Line - 1) + 2, 1);
Match match;
bool abort = false;
var parameters = new List <IUnresolvedParameter> ();
foreach (string parameter in function.Parameters)
{
match = paramExpression.Match(parameter);
if (null == match)
{
abort = true;
break;
}
var typeRef = new DefaultUnresolvedTypeDefinition(string.Format("{0}{1}{2}", match.Groups["type"].Value, match.Groups["subtype"].Value, match.Groups["array"].Value));
var p = new DefaultUnresolvedParameter(typeRef, match.Groups["name"].Value);
parameters.Add(p);
}
if (!abort)
{
parameters.ForEach(p => method.Parameters.Add(p));
}
return(method);
}
public void ImportOpenGenericType()
{
// class C<T, U> { void M<X>() {} }
var c = new DefaultUnresolvedTypeDefinition(string.Empty, "C");
c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, 0, "T"));
c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, 1, "U"));
var m = new DefaultUnresolvedMethod(c, "M");
m.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.Method, 0, "X"));
c.Members.Add(m);
var resolvedC1 = TypeSystemHelper.CreateCompilationAndResolve(c);
var resolvedM1 = resolvedC1.Methods.Single(method => method.Name == "M");
var resolvedC2 = TypeSystemHelper.CreateCompilationAndResolve(c);
var resolvedM2 = resolvedC2.Methods.Single(method => method.Name == "M");
// the types, methods and type parameters differ in the two compilations:
Assert.AreNotEqual(resolvedC1, resolvedC2);
Assert.AreNotEqual(resolvedM1, resolvedM2);
Assert.AreNotEqual(resolvedC1.TypeParameters[1], resolvedC2.TypeParameters[1]);
Assert.AreNotEqual(resolvedM1.TypeParameters[0], resolvedM2.TypeParameters[0]);
// C<U, X>
var pt1 = new ParameterizedType(resolvedC1, new[] { resolvedC1.TypeParameters[1], resolvedM1.TypeParameters[0] });
var pt2 = (ParameterizedType)resolvedC2.Compilation.Import(pt1);
// importing resulted in C<U, X> in the new compilation:
Assert.AreEqual(resolvedC2, pt2.GetDefinition());
Assert.AreEqual(resolvedC2.TypeParameters[1], pt2.TypeArguments[0]);
Assert.AreEqual(resolvedM2.TypeParameters[0], pt2.TypeArguments[1]);
}
//TODO: handle generics
public static IUnresolvedMethod CodeDomToMDDomMethod(CodeMemberMethod method)
{
var meth = new DefaultUnresolvedMethod(null, method.Name);
meth.ReturnType = new DefaultUnresolvedTypeDefinition(method.ReturnType.BaseType);
CodeDomModifiersToMDDom(meth, method.Attributes);
foreach (CodeParameterDeclarationExpression dec in method.Parameters)
{
var paramType = new DefaultUnresolvedTypeDefinition(dec.Type.BaseType);
var par = new DefaultUnresolvedParameter(paramType, dec.Name);
if (dec.Direction == FieldDirection.Ref)
{
par.IsRef = true;
}
else if (dec.Direction == FieldDirection.Out)
{
par.IsOut = true;
}
meth.Parameters.Add(par);
}
return(meth);
}
/// <summary>
/// Create a dummy IMethod from the specified MethodReference
/// </summary>
IMethod CreateFakeMethod(MethodReference methodReference)
{
var m = new DefaultUnresolvedMethod();
ITypeReference declaringTypeReference;
lock (typeReferenceCecilLoader) {
declaringTypeReference = typeReferenceCecilLoader.ReadTypeReference(methodReference.DeclaringType);
if (methodReference.Name == ".ctor" || methodReference.Name == ".cctor")
{
m.SymbolKind = SymbolKind.Constructor;
}
m.Name = methodReference.Name;
m.ReturnType = typeReferenceCecilLoader.ReadTypeReference(methodReference.ReturnType);
m.IsStatic = !methodReference.HasThis;
for (int i = 0; i < methodReference.GenericParameters.Count; i++)
{
m.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.Method, i, methodReference.GenericParameters[i].Name));
}
foreach (var p in methodReference.Parameters)
{
m.Parameters.Add(new DefaultUnresolvedParameter(typeReferenceCecilLoader.ReadTypeReference(p.ParameterType), p.Name));
}
}
var type = declaringTypeReference.Resolve(context);
return(new ResolvedFakeMethod(m, context.WithCurrentTypeDefinition(type.GetDefinition()), type));
}
/// Adds a signal handler to the class
public void BindSignal(Stetic.Signal signal)
{
if (targetObject == null)
{
return;
}
var cls = GetClass();
if (cls == null)
{
return;
}
if (FindSignalHandler(cls.Resolve(project), signal) != null)
{
return;
}
var met = new DefaultUnresolvedMethod(cls, signal.Handler)
{
Accessibility = Accessibility.Protected,
ReturnType = ReflectionHelper.ParseReflectionName(signal.SignalDescriptor.HandlerReturnTypeName)
};
foreach (Stetic.ParameterDescriptor pinfo in signal.SignalDescriptor.HandlerParameters)
{
met.Parameters.Add(new DefaultUnresolvedParameter(ReflectionHelper.ParseReflectionName(pinfo.TypeName), pinfo.Name));
}
var resolvedCls = cls.Resolve(cls.ParsedFile.GetTypeResolveContext(TypeSystemService.GetCompilation(project), cls.Region.Begin)).GetDefinition();
CodeGenerationService.AddNewMember(resolvedCls, cls, met);
}
DefaultUnresolvedMethod CreateDefaultEventAccessor(IUnresolvedEvent ev, string name, IUnresolvedParameter valueParameter)
{
var a = new DefaultUnresolvedMethod(currentTypeDefinition, name);
a.Region = ev.BodyRegion;
a.BodyRegion = ev.BodyRegion;
a.Accessibility = ev.Accessibility;
a.ReturnType = KnownTypeReference.Void;
a.Parameters.Add(valueParameter);
return a;
}
void UpdateMethodRegions(DefaultUnresolvedMethod method, NavigationBarItem item, IDocument document)
{
DomRegion region = item.ToRegionStartingFromOpeningCurlyBrace(document);
method.Region = new DomRegion(
region.BeginLine,
region.BeginColumn,
region.BeginLine,
region.BeginColumn);
method.BodyRegion = region;
}
public void TestMethodSpecifiedInInitialize()
{
var method = new DefaultUnresolvedMethod(new DefaultUnresolvedTypeDefinition("TestFixture"), "Test");
var testMethod = new NUnitTestMethod(testProject, method);
NUnitConsoleApplication app = new NUnitConsoleApplication(new[] { testMethod });
app.NoLogo = false;
app.ShadowCopy = true;
app.NoXmlOutputFile = false;
string expectedCommandLine = "\"C:\\Projects\\MyTests\\MyTests.dll\" /run=\"TestFixture.Test\"";
Assert.AreEqual(expectedCommandLine, app.GetArguments());
}
/// <summary>
/// Adds the 'Invoke', 'BeginInvoke', 'EndInvoke' methods, and a constructor, to the <paramref name="delegateType"/>.
/// </summary>
public static void AddDefaultMethodsToDelegate(DefaultUnresolvedTypeDefinition delegateType, ITypeReference returnType, IEnumerable<IUnresolvedParameter> parameters)
{
if (delegateType == null)
throw new ArgumentNullException("delegateType");
if (returnType == null)
throw new ArgumentNullException("returnType");
if (parameters == null)
throw new ArgumentNullException("parameters");
DomRegion region = delegateType.Region;
region = new DomRegion(region.FileName, region.BeginLine, region.BeginColumn); // remove end position
DefaultUnresolvedMethod invoke = new DefaultUnresolvedMethod(delegateType, "Invoke");
invoke.Accessibility = Accessibility.Public;
invoke.IsSynthetic = true;
foreach (var p in parameters)
invoke.Parameters.Add(p);
invoke.ReturnType = returnType;
invoke.Region = region;
delegateType.Members.Add(invoke);
DefaultUnresolvedMethod beginInvoke = new DefaultUnresolvedMethod(delegateType, "BeginInvoke");
beginInvoke.Accessibility = Accessibility.Public;
beginInvoke.IsSynthetic = true;
foreach (var p in parameters)
beginInvoke.Parameters.Add(p);
beginInvoke.Parameters.Add(delegateAsyncCallbackParameter);
beginInvoke.Parameters.Add(delegateObjectParameter);
beginInvoke.ReturnType = delegateResultParameter.Type;
beginInvoke.Region = region;
delegateType.Members.Add(beginInvoke);
DefaultUnresolvedMethod endInvoke = new DefaultUnresolvedMethod(delegateType, "EndInvoke");
endInvoke.Accessibility = Accessibility.Public;
endInvoke.IsSynthetic = true;
endInvoke.Parameters.Add(delegateResultParameter);
endInvoke.ReturnType = invoke.ReturnType;
endInvoke.Region = region;
delegateType.Members.Add(endInvoke);
DefaultUnresolvedMethod ctor = new DefaultUnresolvedMethod(delegateType, ".ctor");
ctor.EntityType = EntityType.Constructor;
ctor.Accessibility = Accessibility.Public;
ctor.IsSynthetic = true;
ctor.Parameters.Add(delegateObjectParameter);
ctor.Parameters.Add(delegateIntPtrMethodParameter);
ctor.ReturnType = delegateType;
ctor.Region = region;
delegateType.Members.Add(ctor);
}
public static IMethod CreateDummyMethodForFieldInitialization(IMember member, ICompilation compilation)
{
var unresolved = new DefaultUnresolvedMethod(member.DeclaringTypeDefinition.Parts[0], "initialization for " + member.Name)
{
Parameters = { new DefaultUnresolvedParameter(member.ReturnType.ToTypeReference(), "value") },
IsStatic = member.IsStatic,
};
IMethod method = new DefaultResolvedMethod(unresolved, compilation.TypeResolveContext.WithCurrentTypeDefinition(member.DeclaringTypeDefinition));
if (member.DeclaringType is ParameterizedType)
{
method = new SpecializedMethod(method, new TypeParameterSubstitution(classTypeArguments: ((ParameterizedType)member.DeclaringType).TypeArguments, methodTypeArguments: null));
}
return(method);
}
protected IMethod GenerateDefaultConstructor(ITypeDefinition ce)
{
var compilerGeneratedCtor = ce.GetConstructors(true, false).FirstOrDefault(t => t.GetDeclarationBody() == null); //TODO: where is this phantom ctor coming from??? (dan-el)
if (compilerGeneratedCtor == null)
{
var cePart = ce.Parts.First();
var me2 = new DefaultUnresolvedMethod(cePart, ".ctor");
me2.SymbolKind = SymbolKind.Constructor;
me2.IsSynthetic = true;
me2.UnresolvedFile = cePart.UnresolvedFile;
var x = new DefaultResolvedMethod(me2, Compiler.Project.Compilation.TypeResolveContext.WithCurrentTypeDefinition(ce));
compilerGeneratedCtor = x;
}
return(compilerGeneratedCtor);
}
static void CodeDomModifiersToMDDom(DefaultUnresolvedMethod method, MemberAttributes modifiers)
{
if ((modifiers & MemberAttributes.FamilyOrAssembly) != 0)
{
method.Accessibility = Accessibility.ProtectedOrInternal;
}
else if ((modifiers & MemberAttributes.FamilyOrAssembly) != 0)
{
method.Accessibility = Accessibility.ProtectedAndInternal;
}
else if ((modifiers & MemberAttributes.Family) != 0)
{
method.Accessibility = Accessibility.Protected;
}
else if ((modifiers & MemberAttributes.Assembly) != 0)
{
method.Accessibility = Accessibility.Internal;
}
else if ((modifiers & MemberAttributes.Public) != 0)
{
method.Accessibility = Accessibility.Public;
}
else if ((modifiers & MemberAttributes.Private) != 0)
{
method.Accessibility = Accessibility.Private;
}
if ((modifiers & MemberAttributes.Abstract) != 0)
{
method.IsAbstract = true;
}
else if ((modifiers & MemberAttributes.Final) != 0)
{
method.IsSealed = true;
}
else if ((modifiers & MemberAttributes.Static) != 0)
{
method.IsStatic = true;
}
else if ((modifiers & MemberAttributes.Override) != 0)
{
method.IsOverride = true;
}
// else if ((modifiers & MemberAttributes.Const) != 0) { // methods are never const.
// initialState = (initialState & ~ScopeMask) | Modifiers.Const;
// }
}
public override IUnresolvedEntity VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data)
{
DefaultUnresolvedMethod m = new DefaultUnresolvedMethod(currentTypeDefinition, methodDeclaration.Name);
currentMethod = m; // required for resolving type parameters
m.Region = MakeRegion(methodDeclaration);
m.BodyRegion = MakeRegion(methodDeclaration.Body);
if (InheritsConstraints(methodDeclaration) && methodDeclaration.Constraints.Count == 0) {
int index = 0;
foreach (TypeParameterDeclaration tpDecl in methodDeclaration.TypeParameters) {
var tp = new MethodTypeParameterWithInheritedConstraints(index++, tpDecl.Name);
tp.Region = MakeRegion(tpDecl);
ConvertAttributes(tp.Attributes, tpDecl.Attributes);
tp.Variance = tpDecl.Variance;
m.TypeParameters.Add(tp);
}
} else {
ConvertTypeParameters(m.TypeParameters, methodDeclaration.TypeParameters, methodDeclaration.Constraints, EntityType.Method);
}
m.ReturnType = methodDeclaration.ReturnType.ToTypeReference();
ConvertAttributes(m.Attributes, methodDeclaration.Attributes.Where(s => s.AttributeTarget != "return"));
ConvertAttributes(m.ReturnTypeAttributes, methodDeclaration.Attributes.Where(s => s.AttributeTarget == "return"));
ApplyModifiers(m, methodDeclaration.Modifiers);
if (methodDeclaration.IsExtensionMethod) {
m.IsExtensionMethod = true;
currentTypeDefinition.HasExtensionMethods = true;
}
ConvertParameters(m.Parameters, methodDeclaration.Parameters);
if (!methodDeclaration.PrivateImplementationType.IsNull) {
m.Accessibility = Accessibility.None;
m.IsExplicitInterfaceImplementation = true;
m.ExplicitInterfaceImplementations.Add(new DefaultMemberReference(
m.EntityType, methodDeclaration.PrivateImplementationType.ToTypeReference(), m.Name,
m.TypeParameters.Count, GetParameterTypes(m.Parameters)));
}
currentTypeDefinition.Members.Add(m);
currentMethod = null;
if (interningProvider != null) {
m.ApplyInterningProvider(interningProvider);
}
return m;
}
public override IUnresolvedEntity VisitDestructorDeclaration(DestructorDeclaration destructorDeclaration, object data)
{
DefaultUnresolvedMethod dtor = new DefaultUnresolvedMethod(currentTypeDefinition, "Finalize");
dtor.EntityType = EntityType.Destructor;
dtor.Region = MakeRegion(destructorDeclaration);
dtor.BodyRegion = MakeRegion(destructorDeclaration.Body);
dtor.Accessibility = Accessibility.Protected;
dtor.IsOverride = true;
dtor.ReturnType = KnownTypeReference.Void;
ConvertAttributes(dtor.Attributes, destructorDeclaration.Attributes);
currentTypeDefinition.Members.Add(dtor);
if (interningProvider != null) {
dtor.ApplyInterningProvider(interningProvider);
}
return dtor;
}
ICodeContext CreateContext(ITextEditor editor)
{
var compilation = SD.ParserService.GetCompilationForFile(editor.FileName);
var project = SD.ProjectService.FindProjectContainingFile(editor.FileName);
var resolveContext = new SimpleTypeResolveContext(compilation.MainAssembly);
var currentTypeDefinition = new DefaultUnresolvedTypeDefinition(project.RootNamespace, Path.GetFileNameWithoutExtension(editor.FileName));
ITypeReference baseTypeReference = new GetClassTypeReference("System.Web.Mvc", "WebViewPage", 1);
baseTypeReference = new ParameterizedTypeReference(baseTypeReference, new[] { FindModelType(editor) });
currentTypeDefinition.BaseTypes.Add(baseTypeReference);
var currentMethod = new DefaultUnresolvedMethod(currentTypeDefinition, "__ContextStub__");
currentMethod.ReturnType = KnownTypeReference.Void;
currentTypeDefinition.Members.Add(currentMethod);
var currentResolvedTypeDef = new DefaultResolvedTypeDefinition(resolveContext, currentTypeDefinition);
var projectContent = compilation.MainAssembly.UnresolvedAssembly as IProjectContent;
var currentFile = new CSharpUnresolvedFile();
currentFile.RootUsingScope.AddSimpleUsing("System.Web.Mvc");
currentFile.RootUsingScope.AddSimpleUsing("System.Web.Mvc.Ajax");
currentFile.RootUsingScope.AddSimpleUsing("System.Web.Mvc.Html");
currentFile.RootUsingScope.AddSimpleUsing("System.Web.Routing");
currentFile.TopLevelTypeDefinitions.Add(currentTypeDefinition);
if (projectContent != null)
{
compilation = projectContent.AddOrUpdateFiles(currentFile).CreateCompilation(SD.ParserService.GetCurrentSolutionSnapshot());
}
var context = new CSharpTypeResolveContext(compilation.MainAssembly,
currentFile.RootUsingScope.Resolve(compilation),
currentResolvedTypeDef,
currentMethod.CreateResolved(resolveContext.WithCurrentTypeDefinition(currentResolvedTypeDef)));
return(new CSharpResolver(context));
}
internal static Task <IUnresolvedAssembly> LoadModuleAsync(Module module, ICorDebugModule corModule)
{
string name = corModule.GetName();
if (corModule.IsDynamic() == 1 || corModule.IsInMemory() == 1)
{
var defaultUnresolvedAssembly = new DefaultUnresolvedAssembly(name);
var defaultUnresolvedTypeDefinition = new DefaultUnresolvedTypeDefinition("UnknownDynamicType");
var defaultUnresolvedMethod = new DefaultUnresolvedMethod(defaultUnresolvedTypeDefinition, "UnknownMethod");
var defaultUnresolvedField = new DefaultUnresolvedField(defaultUnresolvedTypeDefinition, "UnknownField");
defaultUnresolvedTypeDefinition.Members.Add(defaultUnresolvedMethod);
defaultUnresolvedTypeDefinition.Members.Add(defaultUnresolvedField);
defaultUnresolvedAssembly.AddTypeDefinition(defaultUnresolvedTypeDefinition);
weakTable.Add(defaultUnresolvedAssembly, new ModuleMetadataInfo(module, null));
return(Task.FromResult <IUnresolvedAssembly>(defaultUnresolvedAssembly));
}
//return Task.FromResult(LoadModule(module, name));
return(Task.Run(() => LoadModule(module, name)));
}
public override IUnresolvedEntity VisitOperatorDeclaration(OperatorDeclaration operatorDeclaration, object data)
{
DefaultUnresolvedMethod m = new DefaultUnresolvedMethod(currentTypeDefinition, operatorDeclaration.Name);
m.EntityType = EntityType.Operator;
m.Region = MakeRegion(operatorDeclaration);
m.BodyRegion = MakeRegion(operatorDeclaration.Body);
m.ReturnType = operatorDeclaration.ReturnType.ToTypeReference();
ConvertAttributes(m.Attributes, operatorDeclaration.Attributes.Where(s => s.AttributeTarget != "return"));
ConvertAttributes(m.ReturnTypeAttributes, operatorDeclaration.Attributes.Where(s => s.AttributeTarget == "return"));
ApplyModifiers(m, operatorDeclaration.Modifiers);
ConvertParameters(m.Parameters, operatorDeclaration.Parameters);
currentTypeDefinition.Members.Add(m);
if (interningProvider != null) {
m.ApplyInterningProvider(interningProvider);
}
return m;
}
public ResolvedFakeMethod(DefaultUnresolvedMethod unresolved, ITypeResolveContext parentContext, IType declaringType)
: base(unresolved, parentContext)
{
this.declaringType = declaringType;
}
static void GenerateCU(XmlParsedDocument doc)
{
if (doc.XDocument == null || doc.XDocument.RootElement == null)
{
doc.Add(new Error(ErrorType.Error, "No root node found.", 1, 1));
return;
}
XAttribute rootClass = doc.XDocument.RootElement.Attributes [new XName("x", "Class")];
if (rootClass == null)
{
doc.Add(new Error(ErrorType.Error, "Root node does not contain an x:Class attribute.", 1, 1));
return;
}
bool isApplication = doc.XDocument.RootElement.Name.Name == "Application";
string rootNamespace, rootType, rootAssembly;
XamlG.ParseXmlns(rootClass.Value, out rootType, out rootNamespace, out rootAssembly);
var cu = new DefaultParsedDocument(doc.FileName);
DomRegion rootRegion = doc.XDocument.RootElement.Region;
if (doc.XDocument.RootElement.IsClosed)
{
rootRegion = new DomRegion(doc.XDocument.RootElement.Region.FileName, doc.XDocument.RootElement.Region.Begin, doc.XDocument.RootElement.ClosingTag.Region.End);
}
var declType = new DefaultUnresolvedTypeDefinition(rootNamespace, rootType)
{
Kind = TypeKind.Class,
Accessibility = Accessibility.Public,
Region = rootRegion
};
cu.TopLevelTypeDefinitions.Add(declType);
var initcomp = new DefaultUnresolvedMethod(declType, "InitializeComponent")
{
ReturnType = KnownTypeReference.Void,
Accessibility = Accessibility.Public
};
declType.Members.Add(initcomp);
var _contentLoaded = new DefaultUnresolvedField(declType, "_contentLoaded")
{
ReturnType = KnownTypeReference.Boolean
};
// was missing in the original code: correct ?
// declType.Fields.Add (_contentLoaded);
if (isApplication)
{
return;
}
// cu.Add (new DomUsing (DomRegion.Empty, "System"));
// cu.Add (new DomUsing (DomRegion.Empty, "System.Windows"));
// cu.Add (new DomUsing (DomRegion.Empty, "System.Windows.Controls"));
// cu.Add (new DomUsing (DomRegion.Empty, "System.Windows.Documents"));
// cu.Add (new DomUsing (DomRegion.Empty, "System.Windows.Input"));
// cu.Add (new DomUsing (DomRegion.Empty, "System.Windows.Media"));
// cu.Add (new DomUsing (DomRegion.Empty, "System.Windows.Media.Animation"));
// cu.Add (new DomUsing (DomRegion.Empty, "System.Windows.Shapes"));
// cu.Add (new DomUsing (DomRegion.Empty, "System.Windows.Controls.Primitives"));
// Dictionary<string,string> namespaceMap = new Dictionary<string, string> ();
// namespaceMap["x"] = "http://schemas.microsoft.com/winfx/2006/xaml";
XName nameAtt = new XName("x", "Name");
foreach (XElement el in doc.XDocument.RootElement.AllDescendentElements)
{
XAttribute name = el.Attributes [nameAtt];
if (name != null && name.IsComplete)
{
string type = ResolveType(el);
if (type == null || type.Length == 0)
{
cu.Add(new Error(ErrorType.Error, "Could not find namespace for '" + el.Name.FullName + "'.", el.Region.Begin));
}
else
{
declType.Members.Add(new DefaultUnresolvedField(declType, name.Value)
{
Accessibility = Accessibility.Internal,
Region = el.Region,
ReturnType = new DefaultUnresolvedTypeDefinition(type)
});
}
}
}
}
public override void VisitDocument(AXmlDocument document)
{
currentDocument = document;
AXmlElement rootElement = currentDocument.Children.OfType <AXmlElement>().FirstOrDefault();
if (rootElement != null)
{
string className = rootElement.GetAttributeValue(XamlConst.XamlNamespace, "Class");
string modifier = rootElement.GetAttributeValue(XamlConst.XamlNamespace, "ClassModifier");
if (className != null)
{
TypeDefinition = new DefaultUnresolvedTypeDefinition(className)
{
Kind = TypeKind.Class,
UnresolvedFile = file,
Accessibility = Accessibility.Public,
Region = new DomRegion(file.FileName, textDocument.GetLocation(rootElement.StartOffset), textDocument.GetLocation(rootElement.EndOffset))
};
TypeDefinition.Members.Add(
new DefaultUnresolvedMethod(TypeDefinition, "InitializeComponent")
{
Accessibility = Accessibility.Public,
ReturnType = KnownTypeReference.Void
});
TypeDefinition.Members.Add(
new DefaultUnresolvedField(TypeDefinition, "_contentLoaded")
{
Accessibility = Accessibility.Private,
ReturnType = KnownTypeReference.Boolean
});
var connectMember =
new DefaultUnresolvedMethod(TypeDefinition, "Connect")
{
Accessibility = Accessibility.Private,
ReturnType = KnownTypeReference.Void
};
connectMember.Parameters.Add(new DefaultUnresolvedParameter(KnownTypeReference.Int32, "connectionId"));
connectMember.Parameters.Add(new DefaultUnresolvedParameter(KnownTypeReference.Object, "target"));
TypeDefinition.Members.Add(connectMember);
connectMember.ExplicitInterfaceImplementations.Add(
new DefaultMemberReference(SymbolKind.Method, new GetClassTypeReference(new FullTypeName(typeof(System.Windows.Markup.IComponentConnector).FullName)), "Connect"));
var browsableAttribute = new DefaultUnresolvedAttribute(new GetClassTypeReference(new FullTypeName(typeof(System.ComponentModel.EditorBrowsableAttribute).FullName)));
browsableAttribute.PositionalArguments.Add(
new SimpleConstantValue(
new GetClassTypeReference(new FullTypeName(typeof(System.ComponentModel.EditorBrowsableAttribute).FullName)), System.ComponentModel.EditorBrowsableState.Never
));
connectMember.Attributes.Add(browsableAttribute);
TypeDefinition.BaseTypes.Add(CreateTypeReference(rootElement.Namespace, rootElement.LocalName));
TypeDefinition.BaseTypes.Add(new GetClassTypeReference(new FullTypeName(typeof(System.Windows.Markup.IComponentConnector).FullName)));
if (modifier != null)
{
TypeDefinition.Accessibility = ParseAccessibility(modifier);
}
}
}
base.VisitDocument(document);
}
