public AliasNamespaceReference(string identifier, UsingScope parentUsingScope) { if (identifier == null) throw new ArgumentNullException("identifier"); this.identifier = identifier; this.parentUsingScope = parentUsingScope; }
ResolvedUsingScope MakeUsingScope(string namespaceName = "", string[] usings = null, KeyValuePair <string, string>[] usingAliases = null) { UsingScope usingScope = new UsingScope(); if (!string.IsNullOrEmpty(namespaceName)) { foreach (string element in namespaceName.Split('.')) { usingScope = new UsingScope(usingScope, string.IsNullOrEmpty(usingScope.NamespaceName) ? element : usingScope.NamespaceName + "." + element); } } if (usings != null) { foreach (string u in usings) { usingScope.Usings.Add(MakeReference(u)); } } if (usingAliases != null) { foreach (var pair in usingAliases) { usingScope.UsingAliases.Add(new KeyValuePair <string, TypeOrNamespaceReference>(pair.Key, MakeReference(pair.Value))); } } return(usingScope.Resolve(compilation)); }
public ParsedFile(string fileName, UsingScope rootUsingScope) { if (fileName == null) throw new ArgumentNullException("fileName"); if (rootUsingScope == null) throw new ArgumentNullException("rootUsingScope"); this.fileName = fileName; this.rootUsingScope = rootUsingScope; }
public AliasNamespaceReference(string identifier, UsingScope parentUsingScope) { if (identifier == null) { throw new ArgumentNullException("identifier"); } this.identifier = identifier; this.parentUsingScope = parentUsingScope; }
public SimpleTypeOrNamespaceReference(string identifier, IList<ITypeReference> typeArguments, ITypeDefinition parentTypeDefinition, UsingScope parentUsingScope, bool isInUsingDeclaration = false) { if (identifier == null) throw new ArgumentNullException("identifier"); this.identifier = identifier; this.typeArguments = typeArguments ?? EmptyList<ITypeReference>.Instance; this.parentTypeDefinition = parentTypeDefinition; this.parentUsingScope = parentUsingScope; this.isInUsingDeclaration = isInUsingDeclaration; }
/// <summary> /// Creates a new nested using scope. /// </summary> /// <param name="parent">The parent using scope.</param> /// <param name="namespaceName">The full namespace name.</param> public UsingScope(UsingScope parent, string namespaceName) { if (parent == null) throw new ArgumentNullException("parent"); if (namespaceName == null) throw new ArgumentNullException("namespaceName"); this.parent = parent; this.projectContent = parent.projectContent; this.namespaceName = namespaceName; }
public SimpleTypeOrNamespaceReference(string identifier, IList<ITypeReference> typeArguments, ITypeDefinition parentTypeDefinition, UsingScope parentUsingScope, SimpleNameLookupMode lookupMode = SimpleNameLookupMode.Type) { if (identifier == null) throw new ArgumentNullException("identifier"); this.identifier = identifier; this.typeArguments = typeArguments ?? EmptyList<ITypeReference>.Instance; this.parentTypeDefinition = parentTypeDefinition; this.parentUsingScope = parentUsingScope; this.lookupMode = lookupMode; }
public void AliasToImportedType2() { UsingScope mainUsingScope = new UsingScope(); mainUsingScope.Usings.Add(MakeReference("System")); UsingScope nestedUsingScope = new UsingScope(mainUsingScope, "SomeNamespace"); nestedUsingScope.UsingAliases.Add(new KeyValuePair<string, TypeOrNamespaceReference>("x", MakeReference("String"))); var resolverWithUsing = resolver.WithCurrentUsingScope(nestedUsingScope.Resolve(compilation)); TypeResolveResult trr = (TypeResolveResult)resolverWithUsing.ResolveSimpleName("x", new IType[0]); Assert.AreEqual("System.String", trr.Type.FullName); }
public SimpleTypeOrNamespaceReference(string identifier, IList <ITypeReference> typeArguments, ITypeDefinition parentTypeDefinition, UsingScope parentUsingScope, bool isInUsingDeclaration = false) { if (identifier == null) { throw new ArgumentNullException("identifier"); } this.identifier = identifier; this.typeArguments = typeArguments ?? EmptyList <ITypeReference> .Instance; this.parentTypeDefinition = parentTypeDefinition; this.parentUsingScope = parentUsingScope; this.isInUsingDeclaration = isInUsingDeclaration; }
public MemberTypeOrNamespaceReference(ITypeOrNamespaceReference target, string identifier, IList<ITypeReference> typeArguments, ITypeDefinition parentTypeDefinition, UsingScope parentUsingScope) { if (target == null) throw new ArgumentNullException("target"); if (identifier == null) throw new ArgumentNullException("identifier"); this.target = target; this.identifier = identifier; this.typeArguments = typeArguments ?? EmptyList<ITypeReference>.Instance; this.parentTypeDefinition = parentTypeDefinition; this.parentUsingScope = parentUsingScope; }
public SimpleTypeOrNamespaceReference(string identifier, IList <ITypeReference> typeArguments, ITypeDefinition parentTypeDefinition, UsingScope parentUsingScope, SimpleNameLookupMode lookupMode = SimpleNameLookupMode.Type) { if (identifier == null) { throw new ArgumentNullException("identifier"); } this.identifier = identifier; this.typeArguments = typeArguments ?? EmptyList <ITypeReference> .Instance; this.parentTypeDefinition = parentTypeDefinition; this.parentUsingScope = parentUsingScope; this.lookupMode = lookupMode; }
protected UsingScope MakeUsingScope(string namespaceName) { UsingScope u = new UsingScope(project); if (!string.IsNullOrEmpty(namespaceName)) { foreach (string element in namespaceName.Split('.')) { u = new UsingScope(u, string.IsNullOrEmpty(u.NamespaceName) ? element : u.NamespaceName + "." + element); } } return(u); }
/// <summary> /// Creates a new nested using scope. /// </summary> /// <param name="parent">The parent using scope.</param> /// <param name="namespaceName">The full namespace name.</param> public UsingScope(UsingScope parent, string namespaceName) { if (parent == null) { throw new ArgumentNullException("parent"); } if (namespaceName == null) { throw new ArgumentNullException("namespaceName"); } this.parent = parent; this.projectContent = parent.projectContent; this.namespaceName = namespaceName; }
public MemberTypeOrNamespaceReference(ITypeOrNamespaceReference target, string identifier, IList <ITypeReference> typeArguments, ITypeDefinition parentTypeDefinition, UsingScope parentUsingScope) { if (target == null) { throw new ArgumentNullException("target"); } if (identifier == null) { throw new ArgumentNullException("identifier"); } this.target = target; this.identifier = identifier; this.typeArguments = typeArguments ?? EmptyList <ITypeReference> .Instance; this.parentTypeDefinition = parentTypeDefinition; this.parentUsingScope = parentUsingScope; }
/// <summary> /// Gets all candidate extension methods. /// </summary> /// <remarks> /// The results are stored in nested lists because they are grouped by using scope. /// That is, for "using SomeExtensions; namespace X { using MoreExtensions; ... }", /// the return value will be /// new List { /// new List { all extensions from MoreExtensions }, /// new List { all extensions from SomeExtensions } /// } /// </remarks> public IList <List <IMethod> > GetExtensionMethods() { if (resolver != null) { Debug.Assert(extensionMethods == null); UsingScope oldUsingScope = resolver.CurrentUsingScope; try { resolver.CurrentUsingScope = usingScope; extensionMethods = resolver.GetExtensionMethods(this.TargetType, methodName, typeArguments); } finally { resolver.CurrentUsingScope = oldUsingScope; resolver = null; usingScope = null; } } return(extensionMethods ?? EmptyList <List <IMethod> > .Instance); }
protected ResolveResult Resolve(string code) { CompilationUnit cu = new CSharpParser().Parse(new StringReader(code.Replace("$", ""))); AstLocation[] dollars = FindDollarSigns(code).ToArray(); Assert.AreEqual(2, dollars.Length, "Expected 2 dollar signs marking start+end of desired node"); UsingScope rootUsingScope = resolver.UsingScope; while (rootUsingScope.Parent != null) { rootUsingScope = rootUsingScope.Parent; } ParsedFile parsedFile = new ParsedFile("test.cs", rootUsingScope); TypeSystemConvertVisitor convertVisitor = new TypeSystemConvertVisitor(parsedFile, resolver.UsingScope, null); cu.AcceptVisitor(convertVisitor, null); project.UpdateProjectContent(null, convertVisitor.ParsedFile.TopLevelTypeDefinitions, null, null); FindNodeVisitor fnv = new FindNodeVisitor(dollars[0], dollars[1]); cu.AcceptVisitor(fnv, null); Assert.IsNotNull(fnv.ResultNode, "Did not find DOM node at the specified location"); var navigator = new NodeListResolveVisitorNavigator(new[] { fnv.ResultNode }); ResolveResult rr; using (var context = this.context.Synchronize()) { ResolveVisitor rv = new ResolveVisitor(new CSharpResolver(context), convertVisitor.ParsedFile, navigator); rv.Scan(cu); rr = rv.GetResolveResult(fnv.ResultNode); } Assert.IsNotNull(rr, "ResolveResult is null - did something go wrong while navigating to the target node?"); return(rr); }