public AstType ConvertNamespace(string namespaceName)
{
if (resolver != null) {
// Look if there's an alias to the target namespace
if (UseAliases) {
for (ResolvedUsingScope usingScope = resolver.CurrentUsingScope; usingScope != null; usingScope = usingScope.Parent) {
foreach (var pair in usingScope.UsingAliases) {
NamespaceResolveResult nrr = pair.Value as NamespaceResolveResult;
if (nrr != null && nrr.NamespaceName == namespaceName)
return new SimpleType(pair.Key);
}
}
}
}
int pos = namespaceName.LastIndexOf('.');
if (pos < 0) {
if (IsValidNamespace(namespaceName)) {
return new SimpleType(namespaceName);
} else {
return new MemberType {
Target = new SimpleType("global"),
IsDoubleColon = true,
MemberName = namespaceName
};
}
} else {
string parentNamespace = namespaceName.Substring(0, pos);
string localNamespace = namespaceName.Substring(pos + 1);
return new MemberType {
Target = ConvertNamespace(parentNamespace),
MemberName = localNamespace
};
}
}
bool IsValidNamespace(string firstNamespacePart)
{
if (resolver == null)
return true; // just assume namespaces are valid if we don't have a resolver
NamespaceResolveResult nrr = resolver.ResolveSimpleName(firstNamespacePart, EmptyList<IType>.Instance) as NamespaceResolveResult;
return nrr != null && !nrr.IsError && nrr.NamespaceName == firstNamespacePart;
}
public void SystemNamespaceInFileWithNamespace()
{
string prog =
"namespace Test\n" +
"/*mark*/";
NamespaceResolveResult nrr = Resolve <NamespaceResolveResult>(prog, "System", "/*mark*/");
Assert.AreEqual("System", nrr.Name);
}
public override object VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, CSharpAstResolver astResolver)
{
//resolve namespace declaration
NamespaceResolveResult resolvedNamespace = astResolver.Resolve(namespaceDeclaration) as NamespaceResolveResult;
//create a node for the namespace in the tree
if (resolvedNamespace != null)
{
NamespaceNode node = new NamespaceNode {
Identifier = resolvedNamespace.NamespaceName
};
SourceImporter.SourceImporter.Tree.AddChild(node);
}
return(base.VisitNamespaceDeclaration(namespaceDeclaration, astResolver));
}
AstType ConvertNamespace(string ns)
{
if (resolver != null)
{
// Look if there's an alias to the target namespace
for (UsingScope usingScope = resolver.CurrentUsingScope; usingScope != null; usingScope = usingScope.Parent)
{
foreach (var pair in usingScope.UsingAliases)
{
// maybe add some caching? we're resolving all aliases N times when converting a namespace name with N parts
NamespaceResolveResult nrr = pair.Value.ResolveNamespace(resolver.Context);
if (nrr != null && nrr.NamespaceName == ns)
{
return(new SimpleType(pair.Key));
}
}
}
}
int pos = ns.LastIndexOf('.');
if (pos < 0)
{
if (IsValidNamespace(ns))
{
return(new SimpleType(ns));
}
else
{
return(new MemberType {
Target = new SimpleType("global"),
IsDoubleColon = true,
MemberName = ns
});
}
}
else
{
string parentNamespace = ns.Substring(0, pos);
string localNamespace = ns.Substring(pos + 1);
return(new MemberType {
Target = ConvertNamespace(parentNamespace),
MemberName = localNamespace
});
}
}
bool FullyQualifyNamespaceReference(IdentifierExpression ident, ResolveResult rr)
{
NamespaceResolveResult nrr = rr as NamespaceResolveResult;
if (nrr == null)
{
return(false);
}
if (nrr.Name.IndexOf('.') >= 0)
{
// simple identifier points to complex namespace
ReplaceCurrentNode(MakeFieldReferenceExpression(nrr.Name));
}
else
{
ident.Identifier = nrr.Name;
}
return(true);
}
public void ResolveNamespaceSD2_863()
{
string program = @"using System;
namespace A.C { class D {} }
namespace A.B.C { class D {} }
namespace A.B {
class TestClass {
void Test() {
}
}
}
";
NamespaceResolveResult nrr = Resolve <NamespaceResolveResult>(program, "C", 7);
Assert.AreEqual("A.B.C", nrr.Name, "nrr.Name");
TypeResolveResult trr = Resolve <TypeResolveResult>(program, "C.D", 7);
Assert.AreEqual("A.B.C.D", trr.ResolvedClass.FullyQualifiedName, "trr.ResolvedClass.FullyQualifiedName");
}
public void SetUpFixture()
{
resolver = new PythonResolver();
mockProjectContent = new MockProjectContent();
mockProjectContent.AddExistingNamespaceContents("System", new List <ICompletionEntry>());
string python =
"import System\r\n" +
"class Test:\r\n" +
" def __init__(self):\r\n" +
" System.\r\n";
PythonParser parser = new PythonParser();
string fileName = @"C:\Projects\Test\test.py";
DefaultCompilationUnit cu = parser.Parse(mockProjectContent, fileName, python) as DefaultCompilationUnit;
ParseInformation parseInfo = new ParseInformation(cu);
ExpressionResult expressionResult = new ExpressionResult("System", new DomRegion(4, 2), null, null);
resolveResult = resolver.Resolve(expressionResult, parseInfo, python) as NamespaceResolveResult;
}
void UpdateTick(ParserUpdateStepEventArgs e)
{
this.dynamicHelpTerms.Clear();
ResolveResult res = ResolveAtCaret(e);
if (res == null)
{
return;
}
if (res != null && res.ResolvedType != null)
{
this.AddToStringCollection(res.ResolvedType.FullyQualifiedName);
}
MemberResolveResult member = res as MemberResolveResult;
NamespaceResolveResult nspace = res as NamespaceResolveResult;
MethodGroupResolveResult method = res as MethodGroupResolveResult;
TypeResolveResult types = res as TypeResolveResult;
if (member != null && member.ResolvedMember != null)
{
this.AddToStringCollection(0, member.ResolvedMember.FullyQualifiedName);
}
if (nspace != null)
{
this.AddToStringCollection(0, nspace.Name);
}
if (method != null && method.ContainingType != null)
{
this.AddToStringCollection(0, method.ContainingType.FullyQualifiedName);
}
if (types != null && types.ResolvedClass != null)
{
this.AddToStringCollection(0, types.ResolvedClass.FullyQualifiedName);
}
BuildDynamicHelpList();
}
// Token: 0x06000011 RID: 17 RVA: 0x000023DC File Offset: 0x000005DC
public bool TryResolveType(string identifier, Client.SourceLocation location, out string resolvedType)
{
resolvedType = null;
ProjectDocument document = this.GetDocument(location.FileName);
if (document != null)
{
ResolveResult languageItem = this.GetLanguageItem(document, identifier, location);
NamespaceResolveResult namespaceResolveResult = languageItem as NamespaceResolveResult;
if (namespaceResolveResult != null)
{
resolvedType = namespaceResolveResult.NamespaceName;
return(true);
}
TypeResolveResult typeResolveResult = languageItem as TypeResolveResult;
if (typeResolveResult != null && !typeResolveResult.IsError)
{
resolvedType = typeResolveResult.Type.FullName;
return(true);
}
}
return(false);
}
static string ResolveType(string identifier, SourceLocation location)
{
Document doc = IdeApp.Workbench.GetDocument(location.Filename);
if (doc != null)
{
ITextEditorResolver textEditorResolver = doc.GetContent <ITextEditorResolver> ();
if (textEditorResolver != null)
{
ResolveResult rr = textEditorResolver.GetLanguageItem(doc.Editor.Document.LocationToOffset(location.Line, 1), identifier);
NamespaceResolveResult ns = rr as NamespaceResolveResult;
if (ns != null)
{
return(ns.Namespace);
}
MemberResolveResult result = rr as MemberResolveResult;
if (result != null && (result.ResolvedMember == null || result.ResolvedMember is IType) && result.ResolvedType != null)
{
return(result.ResolvedType.FullName);
}
}
}
return(null);
}
public IEnumerable <MemberReference> FindReferences(Solution solution, NamespaceResolveResult resolveResult, IProgressMonitor monitor)
{
MonoDevelop.Ide.Gui.Document doc = IdeApp.Workbench.ActiveDocument;
ProjectDom dom = doc.Dom;
ICompilationUnit unit = doc.CompilationUnit;
string nspace = resolveResult.Namespace;
IEnumerable <INode> searchNodes = (IEnumerable <INode>) new INode[1] {
new Namespace(nspace)
};
string currentMime = null;
IEnumerable <Tuple <ProjectDom, FilePath> > projFiles = projectFilesExtractor.GetFileNames(solution, dom, unit, monitor);
foreach (Tuple <ProjectDom, FilePath> tuple in projFiles)
{
FilePath filePath = tuple.Item2;
if (string.IsNullOrWhiteSpace(filePath.Extension))
{
continue;
}
if (monitor != null && monitor.IsCancelRequested)
{
break;
}
else
{
string mime = DesktopService.GetMimeTypeForUri(filePath);
currentMime = mime;
TextEditorData editor = TextFileProvider.Instance.GetTextEditorData(filePath);
IParser parser = ProjectDomService.GetParser(filePath);
ParsedDocument parsedDoc = parser.Parse(dom, filePath, editor.Text);
int lastFoundIndex = 0;
int column;
int lineOffset;
for (var i = 0; i < editor.Lines.Count(); i++)
{
var line = editor.GetLineText(i);
if (line != null && line.Contains("using " + nspace + ";"))
{
column = line.IndexOf(nspace);
lineOffset = editor.Text.IndexOf(line, lastFoundIndex);
lastFoundIndex = lineOffset + line.Length;
yield return(new MemberReference(null, filePath, lineOffset + column, i, column, nspace, nspace));
}
if (line != null &&
(line.Trim().StartsWith("namespace " + nspace + ";") || line.Contains("namespace " + nspace + ";")))
{
column = line.IndexOf(nspace);
lineOffset = editor.Text.IndexOf(line, lastFoundIndex);
lastFoundIndex = lineOffset + line.Length;
yield return(new MemberReference(null, filePath, lineOffset + column, i, column, nspace, nspace));
}
}
foreach (var memberRef in FindInnerReferences(monitor, nspace, filePath))
{
yield return(memberRef);
}
}
}
yield break;
}
public IEnumerable <MemberReference> FindReferences(NamespaceResolveResult resolveResult, IProgressMonitor monitor)
{
return(FindReferences(IdeApp.ProjectOperations.CurrentSelectedSolution, resolveResult, monitor));
}
/// <summary>
/// Returns the namespace that is referenced; or null if no such namespace is found.
/// </summary>
public INamespace ResolveNamespace(CSharpResolver resolver)
{
NamespaceResolveResult nrr = Resolve(resolver) as NamespaceResolveResult;
return(nrr != null ? nrr.Namespace : null);
}
Value Visit(NamespaceResolveResult result)
{
throw new GetValueException("Namespace not supported!");
}
public ResolveResult ResolveIdentifier(ResolveVisitor visitor, string identifier)
{
ResolveResult result = null;
if (resultTable.TryGetValue(identifier, out result))
{
return(result);
}
resultTable[identifier] = result;
// Console.WriteLine (lookupVariableLine);
foreach (KeyValuePair <string, List <LocalLookupVariable> > pair in this.lookupTableVisitor.Variables)
{
if (identifier == pair.Key)
{
LocalLookupVariable var = null;
// Console.WriteLine ("--- RP:" + this.resolvePosition + "/" + pair.Value.Count);
foreach (LocalLookupVariable v2 in pair.Value)
{
DomLocation varStartPos = new DomLocation(lookupVariableLine + v2.StartPos.Line, v2.StartPos.Column - 1);
DomLocation varEndPos = new DomLocation(lookupVariableLine + v2.EndPos.Line, v2.EndPos.Column - 1);
// Console.WriteLine (v2.Name + ":" + varStartPos + " <> " + varEndPos + " resolve position:" + this.resolvePosition);
if (varStartPos > this.resolvePosition || (!v2.EndPos.IsEmpty && varEndPos < this.resolvePosition))
{
continue;
}
var = v2;
}
// Console.WriteLine ("var:" + var);
if (var == null)
{
continue;
}
IReturnType varType = null;
IReturnType varTypeUnresolved = null;
if (var.IsQueryContinuation)
{
QueryExpression query = var.Initializer as QueryExpression;
QueryExpressionGroupClause grouBy = query.SelectOrGroupClause as QueryExpressionGroupClause;
DomLocation old = resolvePosition;
try {
resolvePosition = new DomLocation(lookupVariableLine + grouBy.Projection.StartLocation.Line,
grouBy.Projection.StartLocation.Column);
ResolveResult initializerResolve = visitor.Resolve(grouBy.Projection);
ResolveResult groupByResolve = visitor.Resolve(grouBy.GroupBy);
DomReturnType resolved = new DomReturnType(dom.GetType("System.Linq.IGrouping", new IReturnType [] {
DomType.GetComponentType(dom, initializerResolve.ResolvedType), groupByResolve.ResolvedType
}));
varTypeUnresolved = varType = resolved;
} finally {
resolvePosition = old;
}
}
else if ((var.TypeRef == null || var.TypeRef.Type == "var" || var.TypeRef.IsNull))
{
if (var.ParentLambdaExpression != null)
{
ResolveResult lambdaResolve = ResolveLambda(visitor, var.ParentLambdaExpression);
if (lambdaResolve != null)
{
varType = lambdaResolve.ResolvedType;
varTypeUnresolved = lambdaResolve.UnresolvedType;
IType type = Dom.GetType(varType);
if (type != null && type.ClassType == MonoDevelop.Projects.Dom.ClassType.Delegate)
{
IMethod invocationMethod = type.Methods.First();
if (invocationMethod.Parameters.Count > 0)
{
varType = varTypeUnresolved = invocationMethod.Parameters[0].ReturnType;
}
}
}
else
{
varType = varTypeUnresolved = DomReturnType.Void;
}
}
if (var.Initializer != null)
{
ResolveResult initializerResolve = visitor.Resolve(var.Initializer);
// Console.WriteLine ("initializer : "+ var.Initializer + " result:" + initializerResolve);
varType = var.IsLoopVariable ? DomType.GetComponentType(dom, initializerResolve.ResolvedType) : initializerResolve.ResolvedType;
varTypeUnresolved = var.IsLoopVariable ? DomType.GetComponentType(dom, initializerResolve.UnresolvedType) : initializerResolve.UnresolvedType;
// Console.WriteLine ("resolved type:" + initializerResolve.ResolvedType + " is loop : " + var.IsLoopVariable);
// Console.WriteLine (varType);
// Console.WriteLine ("----------");
}
}
else
{
varTypeUnresolved = varType = ConvertTypeReference(var.TypeRef);
}
varType = ResolveType(varType);
result = new LocalVariableResolveResult(
new LocalVariable(CallingMember, identifier, varType,
new DomRegion(lookupVariableLine + var.StartPos.Line, var.StartPos.Column,
lookupVariableLine + var.StartPos.Line, var.EndPos.Column)),
var.IsLoopVariable);
result.ResolvedType = varType;
result.UnresolvedType = varTypeUnresolved;
goto end;
}
}
if (this.callingMember != null)
{
// special handling of property or field return types, they can have the same name as the return type
// ex.: MyType MyType { get; set; } Type1 Type1;
if ((callingMember is IProperty || callingMember is IField) && identifier == callingMember.Name)
{
int pos = editor.GetPositionFromLineColumn(resolvePosition.Line, resolvePosition.Column);
while (pos < editor.TextLength && !Char.IsWhiteSpace(editor.GetCharAt(pos)))
{
pos++;
}
while (pos < editor.TextLength && Char.IsWhiteSpace(editor.GetCharAt(pos)))
{
pos++;
}
StringBuilder memberName = new StringBuilder();
while (pos < editor.TextLength && (Char.IsLetterOrDigit(editor.GetCharAt(pos)) || editor.GetCharAt(pos) == '_'))
{
memberName.Append(editor.GetCharAt(pos));
pos++;
}
//Console.WriteLine ("id: '" + identifier + "' : '" + memberName.ToString () +"'" + (memberName.ToString () == identifier));
if (memberName.ToString() == identifier)
{
result = visitor.CreateResult(callingMember.ReturnType);
goto end;
}
}
if (identifier == "value" && this.callingMember is IProperty)
{
result = new MemberResolveResult(this.callingMember);
result.UnresolvedType = ((IProperty)this.callingMember).ReturnType;
result.ResolvedType = ResolveType(((IProperty)this.callingMember).ReturnType);
goto end;
}
if (this.callingMember is IMethod || this.callingMember is IProperty)
{
ReadOnlyCollection <IParameter> prms = this.callingMember is IMethod
? ((IMethod)this.callingMember).Parameters
: ((IProperty)this.callingMember).Parameters;
if (prms != null)
{
foreach (IParameter para in prms)
{
if (para.Name == identifier)
{
result = new ParameterResolveResult(para);
result.UnresolvedType = para.ReturnType;
result.ResolvedType = ResolveType(para.ReturnType);
goto end;
}
}
}
}
}
IType searchedType = SearchType(identifier);
if (this.callingType != null && dom != null)
{
List <IMember> members = new List <IMember> ();
foreach (IType type in dom.GetInheritanceTree(callingType))
{
members.AddRange(type.SearchMember(identifier, true));
}
bool includeProtected = true;
// filter members
if (this.CallingMember != null)
{
for (int i = 0; i < members.Count; i++)
{
if (this.CallingMember.IsStatic && !members[i].IsStatic ||
!members[i].IsAccessibleFrom(dom, callingType, this.CallingMember, includeProtected))
{
members.RemoveAt(i);
i--;
continue;
}
}
}
if (members.Count > 0)
{
if (members[0] is IMethod)
{
result = new MethodResolveResult(members);
if (CallingMember != null)
{
result.StaticResolve = CallingMember.IsStatic;
}
}
else if (members[0] is IType)
{
result = new MemberResolveResult(null, true);
result.UnresolvedType = result.ResolvedType = new DomReturnType((IType)members[0]);
goto end;
}
else
{
result = new MemberResolveResult(members[0]);
}
result.UnresolvedType = members[0].ReturnType;
result.ResolvedType = ResolveType(members[0].ReturnType);
if (members[0] is IProperty && searchedType != null && result.ResolvedType.FullName == searchedType.FullName)
{
result = new AggregatedResolveResult(result, new MemberResolveResult(null, true)
{
UnresolvedType = new DomReturnType(searchedType),
ResolvedType = new DomReturnType(searchedType)
});
}
goto end;
}
}
if (searchedType != null)
{
result = new MemberResolveResult(null, true);
result.UnresolvedType = result.ResolvedType = new DomReturnType(searchedType);
goto end;
}
if (dom.NamespaceExists(identifier, true))
{
result = new NamespaceResolveResult(identifier);
goto end;
}
if (unit != null && unit.Usings != null)
{
foreach (IUsing u in unit.Usings)
{
if (u.IsFromNamespace && u.Region.Contains(resolvePosition))
{
foreach (string ns in u.Namespaces)
{
if (dom.NamespaceExists(ns + "." + identifier, true))
{
result = new NamespaceResolveResult(ns + "." + identifier);
goto end;
}
}
}
foreach (KeyValuePair <string, IReturnType> alias in u.Aliases)
{
if (alias.Key == identifier || alias.Key + ".?" == identifier)
{
result = new NamespaceResolveResult(alias.Value.FullName);
goto end;
}
}
}
}
end:
if (result != null)
{
result.CallingType = CallingType;
result.CallingMember = CallingMember;
}
resultTable[identifier] = result;
return(result);
}
public ResolveResult Resolve(ExpressionResult expressionResult, DomLocation resolvePosition)
{
this.SetupResolver(resolvePosition);
ResolveVisitor visitor = new ResolveVisitor(this);
ResolveResult result;
// System.Console.WriteLine("expressionResult:" + expressionResult);
if (unit != null && expressionResult.ExpressionContext == ExpressionContext.AttributeArguments)
{
string attributeName = NewCSharpExpressionFinder.FindAttributeName(editor, unit, unit.FileName);
if (attributeName != null)
{
IType type = SearchType(attributeName + "Attribute");
if (type == null)
{
type = SearchType(attributeName);
}
if (type != null)
{
foreach (IProperty property in type.Properties)
{
if (property.Name == expressionResult.Expression)
{
return(new MemberResolveResult(property));
}
}
}
}
}
TypeReference typeRef;
if (expressionResult != null && expressionResult.ExpressionContext != null && expressionResult.ExpressionContext.IsObjectCreation)
{
typeRef = ParseTypeReference(expressionResult);
if (typeRef != null)
{
if (dom.NamespaceExists(typeRef.Type))
{
// System.Console.WriteLine("namespace resolve result");
result = new NamespaceResolveResult(typeRef.Type);
}
else
{
result = visitor.CreateResult(ConvertTypeReference(typeRef));
}
// System.Console.WriteLine("type reference resolve result");
result.ResolvedExpression = expressionResult;
if (dom.GetType(result.ResolvedType) != null)
{
return(result);
}
}
}
expr = ParseExpression(expressionResult);
// System.Console.WriteLine("parsed expression:" + expr);
if (expr == null)
{
// System.Console.WriteLine("Can't parse expression");
return(null);
}
result = visitor.Resolve(expr);
// if (CallingMember == null && result != null)
// result.StaticResolve = true;
// System.Console.WriteLine("result:" + result + "STATIC" + result.StaticResolve);
result.ResolvedExpression = expressionResult;
return(result);
}
public AliasNamespaceResolveResult(string alias, NamespaceResolveResult underlyingResult) : base (underlyingResult.Namespace)
{
this.Alias = alias;
}
string Visit(NamespaceResolveResult result)
{
return("namespace " + result.NamespaceName);
}
public void NamespaceResolveResultNameIsSystem()
{
NamespaceResolveResult namespaceResolveResult = resolveResult as NamespaceResolveResult;
Assert.AreEqual("System", namespaceResolveResult.Name);
}
public AliasNamespaceResolveResult(string alias, NamespaceResolveResult underlyingResult) : base(underlyingResult.Namespace)
{
this.Alias = alias;
}
public override object VisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression, object data)
{
if (memberReferenceExpression == null)
{
return(null);
}
ResolveResult result;
if (String.IsNullOrEmpty(memberReferenceExpression.MemberName))
{
if (memberReferenceExpression.TargetObject is TypeReferenceExpression)
{
result = CreateResult(((TypeReferenceExpression)memberReferenceExpression.TargetObject).TypeReference);
result.StaticResolve = true;
return(result);
}
// if (memberReferenceExpression.TargetObject is ThisReferenceExpression) {
// result = CreateResult (((TypeReferenceExpression)memberReferenceExpression.TargetObject).TypeReference);
// result.StaticResolve = true;
// return result;
// }
// return memberReferenceExpression.TargetObject.AcceptVisitor(this, data);
}
result = memberReferenceExpression.TargetObject.AcceptVisitor(this, data) as ResolveResult;
NamespaceResolveResult namespaceResult = result as NamespaceResolveResult;
if (namespaceResult != null)
{
if (String.IsNullOrEmpty(memberReferenceExpression.MemberName))
{
return(namespaceResult);
}
string fullName = namespaceResult.Namespace + "." + memberReferenceExpression.MemberName;
if (resolver.Dom.NamespaceExists(fullName, true))
{
return(new NamespaceResolveResult(fullName));
}
DomReturnType searchType = new DomReturnType(fullName);
if (memberReferenceExpression.TypeArguments != null)
{
foreach (TypeReference typeRef in memberReferenceExpression.TypeArguments)
{
searchType.AddTypeParameter(NRefactoryResolver.ConvertTypeReference(typeRef));
}
}
IType type = resolver.Dom.GetType(searchType);
if (type != null)
{
result = CreateResult(this.resolver.Unit, new DomReturnType(type));
result.StaticResolve = true;
return(result);
}
return(null);
}
if (result != null && result.ResolvedType != null)
{
foreach (ResolveResult innerResult in result.ResolveResults)
{
ResolveResult resolvedResult = ResolveMemberReference(innerResult, memberReferenceExpression);
if (resolvedResult != null)
{
return(resolvedResult);
}
}
}
else
{
if (result != null)
{
MonoDevelop.Core.LoggingService.LogWarning("Couldn't resolve type " + result.ResolvedType);
}
}
return(null);
}
public JsNode VisitNamespaceResolveResult(NamespaceResolveResult res)
{
throw new NotImplementedException();
}
Value Visit(NamespaceResolveResult result)
{
throw new GetValueException("Namespace not supported!");
}
ResolveResult ResolveMemberAccessOnNamespace(NamespaceResolveResult nrr, string identifier, IList<IType> typeArguments, bool parameterizeResultType)
{
if (typeArguments.Count == 0) {
INamespace childNamespace = nrr.Namespace.GetChildNamespace(identifier);
if (childNamespace != null)
return new NamespaceResolveResult(childNamespace);
}
ITypeDefinition def = nrr.Namespace.GetTypeDefinition(identifier, typeArguments.Count);
if (def != null) {
if (parameterizeResultType && typeArguments.Count > 0)
return new TypeResolveResult(new ParameterizedType(def, typeArguments));
else
return new TypeResolveResult(def);
}
return ErrorResult;
}
string Visit(NamespaceResolveResult result)
{
return "namespace " + result.NamespaceName;
}
