public void ImportOpenGenericType() { // class C<T, U> { void M<X>() {} } var c = new DefaultUnresolvedTypeDefinition(string.Empty, "C"); c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 0, "T")); c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 1, "U")); var m = new DefaultUnresolvedMethod(c, "M"); m.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.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]); }
static IUnresolvedMethod CreateDummyConstructor() { var m = new DefaultUnresolvedMethod { EntityType = EntityType.Constructor, Name = ".ctor", Accessibility = Accessibility.Public, IsSynthetic = true, ReturnType = KnownTypeReference.Void }; m.Freeze(); return(m); }
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; }
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; }
void AddMethod(TypeScriptUnresolvedTypeDefinition parent, NavigationBarItem item, IDocument document) { var method = new DefaultUnresolvedMethod(parent, item.text); UpdateMethodRegions(method, item, document); parent.Members.Add(method); }
MemberList GetMemberList() { var result = LazyInit.VolatileRead(ref this.memberList); if (result != null) { return(result); } List <IUnresolvedMember> unresolvedMembers = new List <IUnresolvedMember>(); List <ITypeResolveContext> contextPerMember = new List <ITypeResolveContext>(); List <PartialMethodInfo> partialMethodInfos = null; bool addDefaultConstructorIfRequired = false; foreach (IUnresolvedTypeDefinition part in parts) { ITypeResolveContext parentContextForPart = part.CreateResolveContext(parentContext); ITypeResolveContext contextForPart = parentContextForPart.WithCurrentTypeDefinition(this); foreach (var member in part.Members) { IUnresolvedMethod method = member as IUnresolvedMethod; if (method != null && method.IsPartial) { // Merge partial method declaration and implementation if (partialMethodInfos == null) { partialMethodInfos = new List <PartialMethodInfo>(); } PartialMethodInfo newInfo = new PartialMethodInfo(method, contextForPart); PartialMethodInfo existingInfo = null; foreach (var info in partialMethodInfos) { if (newInfo.IsSameSignature(info, Compilation.NameComparer)) { existingInfo = info; break; } } if (existingInfo != null) { // Add the unresolved method to the PartialMethodInfo: existingInfo.AddPart(method, contextForPart); } else { partialMethodInfos.Add(newInfo); } } else { unresolvedMembers.Add(member); contextPerMember.Add(contextForPart); } } addDefaultConstructorIfRequired |= part.AddDefaultConstructorIfRequired; } if (addDefaultConstructorIfRequired) { TypeKind kind = this.Kind; if (kind == TypeKind.Class && !this.IsStatic && !unresolvedMembers.Any(m => m.SymbolKind == SymbolKind.Constructor && !m.IsStatic) || kind == TypeKind.Enum || kind == TypeKind.Struct) { contextPerMember.Add(parts[0].CreateResolveContext(parentContext).WithCurrentTypeDefinition(this)); unresolvedMembers.Add(DefaultUnresolvedMethod.CreateDefaultConstructor(parts[0])); } } result = new MemberList(contextPerMember, unresolvedMembers, partialMethodInfos); return(LazyInit.GetOrSet(ref this.memberList, result)); }
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 DefaultResolvedMethod(DefaultUnresolvedMethod unresolved, ITypeResolveContext parentContext) : this(unresolved, parentContext, unresolved.IsExtensionMethod) { }
//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; }
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; }
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 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; }
static void InitTypeDefinition(Dictionary<string, MemberAnnotation[]> typeSemanticInfo, DefaultUnresolvedTypeDefinition typeDef) { foreach(var method_name in typeSemanticInfo.Keys){ var method_info = typeSemanticInfo[method_name]; EntityType type = EntityType.Method; foreach(var method_overload in method_info){ var m = new DefaultUnresolvedMethod(typeDef, method_name); m.EntityType = type; m.HasBody = false; m.ReturnType = PrimitiveTypeReference.Void; //All BVE5 methods have the return type 'void' if(method_overload.Args.Length > 0){ foreach(var arg_annot in method_overload.Args) m.Parameters.Add(TransformParameterInfo(arg_annot)); } typeDef.Members.Add(m); } } }
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); }
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()); }
bool isSynthetic = true; // true if all parts are synthetic public DefaultResolvedTypeDefinition(ITypeResolveContext parentContext, params IUnresolvedTypeDefinition[] parts) { if (parentContext == null || parentContext.CurrentAssembly == null) { throw new ArgumentException("Parent context does not specify any assembly", "parentContext"); } if (parts == null || parts.Length == 0) { throw new ArgumentException("No parts were specified", "parts"); } this.parentContext = parentContext; this.parts = parts; ITypeResolveContext contextForTypeParameters = parts[0].CreateResolveContext(parentContext); contextForTypeParameters = contextForTypeParameters.WithCurrentTypeDefinition(this); this.TypeParameters = parts[0].TypeParameters.CreateResolvedTypeParameters(contextForTypeParameters); List <IUnresolvedAttribute> unresolvedAttributes = new List <IUnresolvedAttribute>(); List <ITypeResolveContext> contextPerAttribute = new List <ITypeResolveContext>(); List <ITypeResolveContext> contextPerMember = new List <ITypeResolveContext>(); bool addDefaultConstructorIfRequired = false; foreach (IUnresolvedTypeDefinition part in parts) { ITypeResolveContext parentContextForPart = part.CreateResolveContext(parentContext); ITypeResolveContext contextForPart = parentContextForPart.WithCurrentTypeDefinition(this); foreach (var attr in part.Attributes) { unresolvedAttributes.Add(attr); contextPerAttribute.Add(parentContextForPart); } foreach (var member in part.Members) { unresolvedMembers.Add(member); contextPerMember.Add(contextForPart); } isAbstract |= part.IsAbstract; isSealed |= part.IsSealed; isShadowing |= part.IsShadowing; isSynthetic &= part.IsSynthetic; // true if all parts are synthetic DefaultUnresolvedTypeDefinition dutd = part as DefaultUnresolvedTypeDefinition; if (dutd != null) { addDefaultConstructorIfRequired |= dutd.AddDefaultConstructorIfRequired; } // internal is the default, so use another part's accessibility until we find a non-internal accessibility if (accessibility == Accessibility.Internal) { accessibility = part.Accessibility; } } if (addDefaultConstructorIfRequired) { TypeKind kind = this.Kind; if (kind == TypeKind.Class && !this.IsStatic && !unresolvedMembers.Any(m => m.EntityType == EntityType.Constructor && !m.IsStatic) || kind == TypeKind.Enum || kind == TypeKind.Struct) { contextPerMember.Add(parts[0].CreateResolveContext(parentContext).WithCurrentTypeDefinition(this)); unresolvedMembers.Add(DefaultUnresolvedMethod.CreateDefaultConstructor(parts[0])); } } this.Attributes = new ProjectedListWithContextPerElement <ITypeResolveContext, IUnresolvedAttribute, IAttribute>(contextPerAttribute, unresolvedAttributes, (c, a) => a.CreateResolvedAttribute(c)); this.resolvedMembers = new ProjectedListWithContextPerElement <ITypeResolveContext, IUnresolvedMember, IMember>(contextPerMember, unresolvedMembers, (c, m) => m.CreateResolved(c)); }
public DefaultResolvedMethod(DefaultUnresolvedMethod unresolved, ITypeResolveContext parentContext) : this(unresolved, parentContext, unresolved.IsExtensionMethod) { }
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; // } }
/// 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.UnresolvedFile.GetTypeResolveContext (TypeSystemService.GetCompilation (project), cls.Region.Begin)).GetDefinition (); CodeGenerationService.AddNewMember (resolvedCls, cls, met); }
IUnresolvedMethod ReadConstructor(ConstructorInfo method, IUnresolvedTypeDefinition parentType, EntityType methodType, IUnresolvedMember accessorOwner) { if (method == null) return null; var m = new DefaultUnresolvedMethod(parentType, method.Name); m.EntityType = methodType; m.AccessorOwner = accessorOwner; m.HasBody = method.GetMethodBody () != null; var genericArguments = method.GetGenericArguments (); if (genericArguments != null) { for (int i = 0; i < genericArguments.Length; i++) { if (genericArguments[i].GenericParameterPosition != i) throw new InvalidOperationException("g.Position != i"); m.TypeParameters.Add(new DefaultUnresolvedTypeParameter( EntityType.Method, i, genericArguments[i].Name)); } for (int i = 0; i < genericArguments.Length; i++) { var tp = (DefaultUnresolvedTypeParameter)m.TypeParameters[i]; AddConstraints(tp, genericArguments[i]); tp.ApplyInterningProvider(interningProvider); } } m.ReturnType = KnownTypeReference.Void; if (HasAnyAttributes(method)) AddAttributes(method, m.Attributes, m.ReturnTypeAttributes); TranslateModifiers(method, m); foreach (var p in method.GetParameters ()) { m.Parameters.Add(ReadParameter(p)); } FinishReadMember(m, method); return m; }
static IUnresolvedMethod CreateDummyConstructor() { var m = new DefaultUnresolvedMethod { EntityType = EntityType.Constructor, Name = ".ctor", Accessibility = Accessibility.Public, IsSynthetic = true, ReturnType = KnownTypeReference.Void }; m.Freeze(); return m; }
IUnresolvedMethod ReadMethod(MethodInfo method, IUnresolvedTypeDefinition parentType, EntityType methodType, IUnresolvedMember accessorOwner) { if (method == null) return null; var m = new DefaultUnresolvedMethod(parentType, method.Name); m.EntityType = methodType; m.AccessorOwner = accessorOwner; m.HasBody = method.GetMethodBody () != null; var genericArguments = method.GetGenericArguments (); if (genericArguments != null) { for (int i = 0; i < genericArguments.Length; i++) { if (genericArguments[i].GenericParameterPosition != i) throw new InvalidOperationException("g.Position != i"); m.TypeParameters.Add(new DefaultUnresolvedTypeParameter( EntityType.Method, i, genericArguments[i].Name)); } for (int i = 0; i < genericArguments.Length; i++) { var tp = (DefaultUnresolvedTypeParameter)m.TypeParameters[i]; AddConstraints(tp, genericArguments[i]); tp.ApplyInterningProvider(interningProvider); } } m.ReturnType = ReadTypeReference(method.ReturnType, typeAttributes: method.ReturnParameter.CustomAttributes); if (HasAnyAttributes(method)) AddAttributes(method, m.Attributes, m.ReturnTypeAttributes); TranslateModifiers(method, m); foreach (var p in method.GetParameters ()) { m.Parameters.Add(ReadParameter(p)); } // mark as extension method if the attribute is set if (method.IsStatic && HasExtensionAttribute(method)) { m.IsExtensionMethod = true; } int lastDot = method.Name.LastIndexOf('.'); if (lastDot >= 0 /*&& method.HasOverrides*/) { // To be consistent with the parser-initialized type system, shorten the method name: m.Name = method.Name.Substring(lastDot + 1); m.IsExplicitInterfaceImplementation = true; foreach (var or in method.__GetMethodImpls ()) { m.ExplicitInterfaceImplementations.Add(new DefaultMemberReference( accessorOwner != null ? EntityType.Accessor : EntityType.Method, ReadTypeReference(or.DeclaringType), or.Name, or.GetGenericArguments ().Length, m.Parameters.Select(p => p.Type).ToList())); } } FinishReadMember(m, method); 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; }
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); }