Mono.CSharp.NamespaceEntry.Lookup C# (CSharp) Method

		private FullNamedExpression Lookup (string name, int arity, Location loc, bool ignore_cs0104)
		{
			//
			// Check whether it's in the namespace.
			//
			FullNamedExpression fne = ns.Lookup (Compiler, name, arity, loc);

			//
			// Check aliases. 
			//
			if (using_aliases != null && arity == 0) {
				foreach (UsingAliasEntry ue in using_aliases) {
					if (ue.Alias == name) {
						if (fne != null) {
							if (Doppelganger != null) {
								// TODO: Namespace has broken location
								//Report.SymbolRelatedToPreviousError (fne.Location, null);
								Compiler.Report.SymbolRelatedToPreviousError (ue.Location, null);
								Compiler.Report.Error (576, loc,
									"Namespace `{0}' contains a definition with same name as alias `{1}'",
									GetSignatureForError (), name);
							} else {
								return fne;
							}
						}

						return ue.Resolve (Doppelganger ?? this, Doppelganger == null);
					}
				}
			}

			if (fne != null) {
				if (!((fne.Type.Modifiers & Modifiers.INTERNAL) != 0 && !fne.Type.MemberDefinition.IsInternalAsPublic (RootContext.ToplevelTypes.DeclaringAssembly)))
					return fne;
			}

			if (IsImplicit)
				return null;

			//
			// Check using entries.
			//
			FullNamedExpression match = null;
			foreach (Namespace using_ns in GetUsingTable ()) {
				// A using directive imports only types contained in the namespace, it
				// does not import any nested namespaces
				fne = using_ns.LookupType (Compiler, name, arity, false, loc);
				if (fne == null)
					continue;

				if (match == null) {
					match = fne;
					continue;
				}

				// Prefer types over namespaces
				var texpr_fne = fne as TypeExpr;
				var texpr_match = match as TypeExpr;
				if (texpr_fne != null && texpr_match == null) {
					match = fne;
					continue;
				} else if (texpr_fne == null) {
					continue;
				}

				if (ignore_cs0104)
					return match;

				// It can be top level accessibility only
				var better = Namespace.IsImportedTypeOverride (texpr_match.Type, texpr_fne.Type);
				if (better == null) {
					Compiler.Report.SymbolRelatedToPreviousError (texpr_match.Type);
					Compiler.Report.SymbolRelatedToPreviousError (texpr_fne.Type);
					Compiler.Report.Error (104, loc, "`{0}' is an ambiguous reference between `{1}' and `{2}'",
						name, texpr_match.GetSignatureForError (), texpr_fne.GetSignatureForError ());
					return match;
				}

				if (better == texpr_fne.Type)
					match = texpr_fne;
			}

			return match;
		}

        public FullNamedExpression LookupNamespaceOrType(DeclSpace ds, string name, Location loc, bool ignore_cs0104)
        {
            // Precondition: Only simple names (no dots) will be looked up with this function.
            FullNamedExpression resolved = null;

            for (NamespaceEntry curr_ns = this; curr_ns != null; curr_ns = curr_ns.ImplicitParent)
            {
                if ((resolved = curr_ns.Lookup(ds, name, loc, ignore_cs0104)) != null)
                {
                    break;
                }
            }
            return(resolved);
        }