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