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]); }
public void GetGenericNestedTypeOfBoundGenericClass() { // class A<X> { class B<Y> { } } DefaultUnresolvedTypeDefinition a = new DefaultUnresolvedTypeDefinition(string.Empty, "A"); a.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 0, "X")); DefaultUnresolvedTypeDefinition b = new DefaultUnresolvedTypeDefinition(a, "B"); b.TypeParameters.Add(a.TypeParameters[0]); b.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 1, "Y")); a.NestedTypes.Add(b); var compilation = TypeSystemHelper.CreateCompilation(a, b); ITypeDefinition resolvedA = compilation.MainAssembly.GetTypeDefinition(a.FullTypeName); ITypeDefinition resolvedB = compilation.MainAssembly.GetTypeDefinition(b.FullTypeName); // A<> gets self-parameterized, B<> stays unbound Assert.AreEqual("A`1+B`1[[`0],[]]", resolvedA.GetNestedTypes().Single().ReflectionName); ParameterizedType pt = new ParameterizedType(resolvedA, new [] { compilation.FindType(KnownTypeCode.String) }); Assert.AreEqual("A`1+B`1[[System.String],[]]", pt.GetNestedTypes().Single().ReflectionName); }
//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); }
public void MultipleInheritanceTest() { DefaultUnresolvedTypeDefinition b1 = new DefaultUnresolvedTypeDefinition(string.Empty, "B1"); b1.Kind = TypeKind.Interface; b1.Members.Add(new DefaultUnresolvedProperty(b1, "P1")); DefaultUnresolvedTypeDefinition b2 = new DefaultUnresolvedTypeDefinition(string.Empty, "B2"); b2.Kind = TypeKind.Interface; b2.Members.Add(new DefaultUnresolvedProperty(b2, "P2")); DefaultUnresolvedTypeDefinition c = new DefaultUnresolvedTypeDefinition(string.Empty, "C"); c.Kind = TypeKind.Interface; c.BaseTypes.Add(b1); c.BaseTypes.Add(b2); var compilation = TypeSystemHelper.CreateCompilation(b1, b2, c); ITypeDefinition resolvedC = compilation.MainAssembly.GetTypeDefinition(c.FullTypeName); Assert.AreEqual(new[] { "P1", "P2" }, resolvedC.GetProperties().Select(p => p.Name).ToArray()); // Test that there's only one copy of ToString(): Assert.AreEqual(1, resolvedC.GetMethods(m => m.Name == "ToString").Count()); }
public void EmptyClassHasToString() { DefaultUnresolvedTypeDefinition c = new DefaultUnresolvedTypeDefinition(string.Empty, "C"); var resolvedC = TypeSystemHelper.CreateCompilationAndResolve(c); Assert.AreEqual("System.Object.ToString", resolvedC.GetMethods(m => m.Name == "ToString").Single().FullName); }
public void ExpansiveInheritance() { var a = new DefaultUnresolvedTypeDefinition(string.Empty, "A"); var b = new DefaultUnresolvedTypeDefinition(string.Empty, "B"); // interface A<in U> a.Kind = TypeKind.Interface; a.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 0, "U") { Variance = VarianceModifier.Contravariant }); // interface B<X> : A<A<B<X>>> { } b.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 0, "X")); b.BaseTypes.Add(new ParameterizedTypeReference( a, new[] { new ParameterizedTypeReference( a, new [] { new ParameterizedTypeReference( b, new [] { new TypeParameterReference(EntityType.TypeDefinition, 0) } ) }) })); ICompilation compilation = new SimpleCompilation(CecilLoaderTests.Mscorlib); ITypeDefinition resolvedA = compilation.MainAssembly.GetTypeDefinition(a); ITypeDefinition resolvedB = compilation.MainAssembly.GetTypeDefinition(b); IType type1 = new ParameterizedType(resolvedB, new[] { compilation.FindType(KnownTypeCode.Double) }); IType type2 = new ParameterizedType(resolvedA, new [] { new ParameterizedType(resolvedB, new[] { compilation.FindType(KnownTypeCode.String) }) }); Assert.IsFalse(conversions.ImplicitConversion(type1, type2)); }
static void ApplyModifiers(DefaultUnresolvedTypeDefinition td, Modifiers modifiers) { td.Accessibility = GetAccessibility(modifiers) ?? (td.DeclaringTypeDefinition != null ? Accessibility.Private : Accessibility.Internal); td.IsAbstract = (modifiers & (Modifiers.Abstract | Modifiers.Static)) != 0; td.IsSealed = (modifiers & (Modifiers.Sealed | Modifiers.Static)) != 0; td.IsShadowing = (modifiers & Modifiers.New) != 0; }
public void ClassDerivingFromItself() { // class C : C {} var c = new DefaultUnresolvedTypeDefinition(string.Empty, "C"); c.BaseTypes.Add(c); ITypeDefinition resolvedC = Resolve(c); Assert.AreEqual(new [] { resolvedC }, resolvedC.GetAllBaseTypes().ToArray()); }
public void ClassDerivingFromParameterizedVersionOfItself() { // class C<X> : C<C<X>> {} var c = new DefaultUnresolvedTypeDefinition(string.Empty, "C"); c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 0, "X")); c.BaseTypes.Add(new ParameterizedTypeReference(c, new [] { new ParameterizedTypeReference(c, new [] { new TypeParameterReference(EntityType.TypeDefinition, 0) }) })); ITypeDefinition resolvedC = Resolve(c); Assert.AreEqual(new [] { resolvedC }, resolvedC.GetAllBaseTypes().ToArray()); }
public void TwoClassesDerivingFromEachOther() { // class C1 : C2 {} class C2 : C1 {} var c1 = new DefaultUnresolvedTypeDefinition(string.Empty, "C1"); var c2 = new DefaultUnresolvedTypeDefinition(string.Empty, "C2"); c1.BaseTypes.Add(c2); c2.BaseTypes.Add(c1); ITypeDefinition resolvedC1 = Resolve(c1); ITypeDefinition resolvedC2 = Resolve(c2); Assert.AreEqual(new [] { resolvedC2, resolvedC1 }, resolvedC1.GetAllBaseTypes().ToArray()); }
/// <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); }
static void AddPlaceholders(Step action, IUnresolvedMethod method) { var parameters = new List <IUnresolvedParameter> (); int index = 0; foreach (var placeholder in action.Placeholders) { var typeRef = new DefaultUnresolvedTypeDefinition(placeholder.Name); var p = new DefaultUnresolvedParameter(typeRef, "p" + index); method.Parameters.Add(p); index++; } }
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 void ClassDerivingFromTwoInstanciationsOfIEnumerable() { // class C : IEnumerable<int>, IEnumerable<uint> {} var c = new DefaultUnresolvedTypeDefinition(string.Empty, "C"); c.BaseTypes.Add(typeof(IEnumerable <int>).ToTypeReference()); c.BaseTypes.Add(typeof(IEnumerable <uint>).ToTypeReference()); ITypeDefinition resolvedC = Resolve(c); IType[] expected = { resolvedC, compilation.FindType(typeof(IEnumerable <int>)), compilation.FindType(typeof(IEnumerable <uint>)), compilation.FindType(typeof(IEnumerable)), compilation.FindType(typeof(object)) }; Assert.AreEqual(expected, resolvedC.GetAllBaseTypes().OrderBy(t => t.ReflectionName).ToArray()); }
public void StructImplementingIEquatable() { // struct S : IEquatable<S> {} // don't use a Cecil-loaded struct for this test; we're testing the implicit addition of System.ValueType var s = new DefaultUnresolvedTypeDefinition(string.Empty, "S"); s.Kind = TypeKind.Struct; s.BaseTypes.Add(new ParameterizedTypeReference(typeof(IEquatable <>).ToTypeReference(), new[] { s })); ITypeDefinition resolvedS = Resolve(s); IType[] expected = { resolvedS, s.BaseTypes[0].Resolve(new SimpleTypeResolveContext(resolvedS)), compilation.FindType(typeof(object)), compilation.FindType(typeof(ValueType)) }; Assert.AreEqual(expected, resolvedS.GetAllBaseTypes().OrderBy(t => t.ReflectionName).ToArray()); }
public void TypeParameterDerivingFromOtherTypeParameterInheritsEffectiveBaseClass() { // class C<T, U> where T : List<string> where U : T var c = new DefaultUnresolvedTypeDefinition(string.Empty, "C"); c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 0, "T") { Constraints = { typeof(List <string>).ToTypeReference() } }); c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 1, "U") { Constraints = { new TypeParameterReference(EntityType.TypeDefinition, 0) } }); ITypeDefinition resolvedC = new SimpleCompilation(CecilLoaderTests.Mscorlib).MainAssembly.GetTypeDefinition(c); Assert.AreEqual(true, resolvedC.TypeParameters[0].IsReferenceType); Assert.AreEqual(true, resolvedC.TypeParameters[1].IsReferenceType); Assert.AreEqual("System.Collections.Generic.List`1[[System.String]]", resolvedC.TypeParameters[0].EffectiveBaseClass.ReflectionName); Assert.AreEqual("System.Collections.Generic.List`1[[System.String]]", resolvedC.TypeParameters[1].EffectiveBaseClass.ReflectionName); }
public void TypeParameterDerivingFromOtherTypeParameterDoesNotInheritReferenceConstraint() { // class C<T, U> where T : class where U : T var c = new DefaultUnresolvedTypeDefinition(string.Empty, "C"); c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, 0, "T") { HasReferenceTypeConstraint = true }); c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, 1, "U") { Constraints = { new TypeParameterReference(SymbolKind.TypeDefinition, 0) } }); ITypeDefinition resolvedC = TypeSystemHelper.CreateCompilationAndResolve(c); // At runtime, we might have T=System.ValueType and U=int, so C# can't inherit the 'class' constraint // from one type parameter to another. Assert.AreEqual(true, resolvedC.TypeParameters[0].IsReferenceType); Assert.IsNull(resolvedC.TypeParameters[1].IsReferenceType); }
public void TypeParameterDerivingFromOtherTypeParameterInheritsEffectiveBaseClass() { // class C<T, U> where T : List<string> where U : T var c = new DefaultUnresolvedTypeDefinition(string.Empty, "C"); c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, 0, "T") { Constraints = { typeof(List <string>).ToTypeReference() } }); c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, 1, "U") { Constraints = { new TypeParameterReference(SymbolKind.TypeDefinition, 0) } }); ITypeDefinition resolvedC = TypeSystemHelper.CreateCompilationAndResolve(c); Assert.AreEqual(true, resolvedC.TypeParameters[0].IsReferenceType); Assert.AreEqual(true, resolvedC.TypeParameters[1].IsReferenceType); Assert.AreEqual("System.Collections.Generic.List`1[[System.String]]", resolvedC.TypeParameters[0].EffectiveBaseClass.ReflectionName); Assert.AreEqual("System.Collections.Generic.List`1[[System.String]]", resolvedC.TypeParameters[1].EffectiveBaseClass.ReflectionName); }
static object AddLanguageItem(ProjectInformation pi, DefaultUnresolvedTypeDefinition klass, LanguageItem li, string[] contentLines) { if (li is Class || li is Structure || li is Enumeration) { var type = LanguageItemToIType(pi, li, contentLines); klass.NestedTypes.Add(type); return(type); } if (li is Function) { var method = FunctionToIMethod(pi, klass, (Function)li, contentLines); klass.Members.Add(method); return(method); } var field = LanguageItemToIField(klass, li, contentLines); klass.Members.Add(field); return(field); }
public void TypeParameterDerivingFromOtherTypeParameterDoesNotInheritReferenceConstraint() { // class C<T, U> where T : class where U : T var c = new DefaultUnresolvedTypeDefinition(string.Empty, "C"); c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 0, "T") { HasReferenceTypeConstraint = true }); c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 1, "U") { Constraints = { new TypeParameterReference(EntityType.TypeDefinition, 0) } }); ITypeDefinition resolvedC = new SimpleCompilation(CecilLoaderTests.Mscorlib).MainAssembly.GetTypeDefinition(c); // At runtime, we might have T=System.ValueType and U=int, so C# can't inherit the 'class' constraint // from one type parameter to another. Assert.AreEqual(true, resolvedC.TypeParameters[0].IsReferenceType); Assert.IsNull(resolvedC.TypeParameters[1].IsReferenceType); }
public override ParsedDocument Parse(bool storeAst, string fileName, TextReader reader, Project project = null) { var doc = new DefaultParsedDocument(fileName); doc.Flags |= ParsedDocumentFlags.NonSerializable; ProjectInformation pi = ProjectInformationManager.Instance.Get(project); string content = reader.ReadToEnd(); string[] contentLines = content.Split(new string[] { Environment.NewLine }, StringSplitOptions.None); var globals = new DefaultUnresolvedTypeDefinition("", GettextCatalog.GetString("(Global Scope)")); lock (pi) { // Add containers to type list foreach (LanguageItem li in pi.Containers()) { if (null == li.Parent && FilePath.Equals(li.File, fileName)) { var tmp = AddLanguageItem(pi, globals, li, contentLines) as IUnresolvedTypeDefinition; if (null != tmp) { doc.TopLevelTypeDefinitions.Add(tmp); } } } // Add global category for unscoped symbols foreach (LanguageItem li in pi.InstanceMembers()) { if (null == li.Parent && FilePath.Equals(li.File, fileName)) { AddLanguageItem(pi, globals, li, contentLines); } } } doc.TopLevelTypeDefinitions.Add(globals); return(doc); }
public void ValueTypeParameterDerivingFromReferenceTypeParameter() { // class C<T, U> where T : class where U : struct, T var c = new DefaultUnresolvedTypeDefinition(string.Empty, "C"); c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 0, "T") { HasReferenceTypeConstraint = true }); c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 1, "U") { HasValueTypeConstraint = true, Constraints = { new TypeParameterReference(EntityType.TypeDefinition, 0) } }); ITypeDefinition resolvedC = TypeSystemHelper.CreateCompilation(c).MainAssembly.GetTypeDefinition(c); // At runtime, we might have T=System.ValueType and U=int, so C# can't inherit the 'class' constraint // from one type parameter to another. Assert.AreEqual(true, resolvedC.TypeParameters[0].IsReferenceType); Assert.AreEqual(false, resolvedC.TypeParameters[1].IsReferenceType); }
/// <summary> /// Create an IMember from a LanguageItem, /// using the source document to locate declaration bounds. /// </summary> /// <param name="pi"> /// A <see cref="ProjectInformation"/> for the current project. /// </param> /// <param name="item"> /// A <see cref="LanguageItem"/>: The item to convert. /// </param> /// <param name="contentLines"> /// A <see cref="System.String[]"/>: The document in which item is defined. /// </param> static DefaultUnresolvedTypeDefinition LanguageItemToIType(ProjectInformation pi, LanguageItem item, string[] contentLines) { var klass = new DefaultUnresolvedTypeDefinition("", item.File); if (item is Class || item is Structure) { klass.Region = new DomRegion((int)item.Line, 1, FindFunctionEnd(contentLines, (int)item.Line - 1) + 2, 1); klass.Kind = item is Class ? TypeKind.Class : TypeKind.Struct; foreach (LanguageItem li in pi.AllItems()) { if (klass.Equals(li.Parent) && FilePath.Equals(li.File, item.File)) { AddLanguageItem(pi, klass, li, contentLines); } } return(klass); } klass.Region = new DomRegion((int)item.Line, 1, (int)item.Line + 1, 1); klass.Kind = TypeKind.Enum; return(klass); }
public override System.Threading.Tasks.Task <ParsedDocument> Parse(ParseOptions options, System.Threading.CancellationToken cancellationToken) { var fileName = options.FileName; var project = options.Project; var doc = new DefaultParsedDocument(fileName); doc.Flags |= ParsedDocumentFlags.NonSerializable; ProjectInformation pi = ProjectInformationManager.Instance.Get(project); string content = options.Content.Text; string[] contentLines = content.Split(new string[] { Environment.NewLine }, StringSplitOptions.None); var globals = new DefaultUnresolvedTypeDefinition("", GettextCatalog.GetString("(Global Scope)")); lock (pi) { // Add containers to type list foreach (LanguageItem li in pi.Containers()) { if (null == li.Parent && FilePath.Equals(li.File, fileName)) { var tmp = AddLanguageItem(pi, globals, li, contentLines) as IUnresolvedTypeDefinition; if (null != tmp) /*doc.TopLevelTypeDefinitions.Add (tmp);*/ } { } } // Add global category for unscoped symbols foreach (LanguageItem li in pi.InstanceMembers()) { if (null == li.Parent && FilePath.Equals(li.File, fileName)) { AddLanguageItem(pi, globals, li, contentLines); } } } //doc.TopLevelTypeDefinitions.Add (globals); return(System.Threading.Tasks.Task.FromResult((ParsedDocument)doc)); }
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 SkeetEvilOverloadResolution() { // http://msmvps.com/blogs/jon_skeet/archive/2010/11/02/evil-code-overload-resolution-workaround.aspx // static void Foo<T>(T? ignored = default(T?)) where T : struct var m1 = MakeUnresolvedMethod(); m1.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.Method, 0, "T") { HasValueTypeConstraint = true }); m1.Parameters.Add(MakeOptionalParameter( NullableType.Create(new TypeParameterReference(EntityType.Method, 0)), "ignored" )); // class ClassConstraint<T> where T : class {} var classConstraint = new DefaultUnresolvedTypeDefinition(string.Empty, "ClassConstraint"); classConstraint.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 0, "T") { HasReferenceTypeConstraint = true }); // static void Foo<T>(ClassConstraint<T> ignored = default(ClassConstraint<T>)) // where T : class var m2 = MakeUnresolvedMethod(); m2.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.Method, 0, "T") { HasReferenceTypeConstraint = true }); m2.Parameters.Add(MakeOptionalParameter( new ParameterizedTypeReference(classConstraint, new[] { new TypeParameterReference(EntityType.Method, 0) }), "ignored" )); // static void Foo<T>() var m3 = MakeUnresolvedMethod(); m3.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.Method, 0, "T")); var context = new SimpleTypeResolveContext(compilation.MainAssembly); IMethod resolvedM1 = (IMethod)m1.CreateResolved(context); IMethod resolvedM2 = (IMethod)m2.CreateResolved(context); IMethod resolvedM3 = (IMethod)m3.CreateResolved(context); // Call: Foo<int>(); OverloadResolution o; o = new OverloadResolution(compilation, new ResolveResult[0], typeArguments: new[] { compilation.FindType(typeof(int)) }); Assert.AreEqual(OverloadResolutionErrors.None, o.AddCandidate(resolvedM1)); Assert.AreEqual(OverloadResolutionErrors.ConstructedTypeDoesNotSatisfyConstraint, o.AddCandidate(resolvedM2)); Assert.AreSame(resolvedM1, o.BestCandidate); // Call: Foo<string>(); o = new OverloadResolution(compilation, new ResolveResult[0], typeArguments: new[] { compilation.FindType(typeof(string)) }); Assert.AreEqual(OverloadResolutionErrors.ConstructedTypeDoesNotSatisfyConstraint, o.AddCandidate(resolvedM1)); Assert.AreEqual(OverloadResolutionErrors.None, o.AddCandidate(resolvedM2)); Assert.AreSame(resolvedM2, o.BestCandidate); // Call: Foo<int?>(); o = new OverloadResolution(compilation, new ResolveResult[0], typeArguments: new[] { compilation.FindType(typeof(int?)) }); Assert.AreEqual(OverloadResolutionErrors.ConstructedTypeDoesNotSatisfyConstraint, o.AddCandidate(resolvedM1)); Assert.AreEqual(OverloadResolutionErrors.ConstructedTypeDoesNotSatisfyConstraint, o.AddCandidate(resolvedM2)); Assert.AreEqual(OverloadResolutionErrors.None, o.AddCandidate(resolvedM3)); Assert.AreSame(resolvedM3, o.BestCandidate); }
ParsedDocument ITypeSystemParser.Parse(bool storeAst, string fileName, TextReader textReader, Project project = null) { var doc = new DefaultParsedDocument(fileName); DefaultUnresolvedTypeDefinition currentFile = null; DefaultUnresolvedProperty currentRegion = null; string eol = Environment.NewLine; string content = textReader.ReadToEnd(); Match eolMatch = eolExpression.Match(content); if (eolMatch != null && eolMatch.Success) { eol = eolMatch.Groups ["eol"].Value; } string[] lines = content.Split(new string[] { eol }, StringSplitOptions.None); int linenum = 1; Match lineMatch; foreach (string line in lines) { lineMatch = fileHeaderExpression.Match(line.Trim()); if (lineMatch != null && lineMatch.Success) { if (currentFile != null) // Close out previous file region { currentFile.BodyRegion = new DomRegion(currentFile.BodyRegion.BeginLine, currentFile.BodyRegion.BeginColumn, linenum - 1, int.MaxValue); } if (currentRegion != null) // Close out previous chunk region { currentRegion.BodyRegion = new DomRegion(currentRegion.BodyRegion.BeginLine, currentRegion.BodyRegion.BeginColumn, linenum - 1, int.MaxValue); } // Create new file region currentFile = new DefaultUnresolvedTypeDefinition(string.Empty, string.Empty); currentFile.Region = currentFile.BodyRegion = new DomRegion(lastToken(lineMatch.Groups ["filepath"].Value), linenum, line.Length + 1, linenum, int.MaxValue); doc.TopLevelTypeDefinitions.Add(currentFile); } else { lineMatch = chunkExpression.Match(line); if (lineMatch != null && lineMatch.Success && currentFile != null) { if (currentRegion != null) // Close out previous chunk region { currentRegion.BodyRegion = new DomRegion(currentRegion.BodyRegion.BeginLine, currentRegion.BodyRegion.BeginColumn, linenum - 1, int.MaxValue); } // Create new chunk region currentRegion = new DefaultUnresolvedProperty(currentFile, lineMatch.Groups ["chunk"].Value); currentRegion.Region = currentRegion.BodyRegion = new DomRegion(currentFile.Region.FileName, linenum, line.Length + 1, linenum, int.MaxValue); currentFile.Members.Add(currentRegion); } } ++linenum; } // Close out trailing regions if (currentFile != null) { currentFile.BodyRegion = new DomRegion(currentFile.BodyRegion.BeginLine, currentFile.BodyRegion.BeginColumn, Math.Max(1, linenum - 2), int.MaxValue); } if (currentRegion != null) { currentRegion.BodyRegion = new DomRegion(currentRegion.BodyRegion.BeginLine, currentRegion.BodyRegion.BeginColumn, Math.Max(1, linenum - 2), int.MaxValue); } return(doc); }
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) }); } } } }