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

		public FullNamedExpression Lookup (CompilerContext ctx, string name, int arity, Location loc)
		{
			if (arity == 0 && namespaces.ContainsKey (name))
				return namespaces [name];

			return LookupType (ctx, name, arity, false, loc);
		}

        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);
        }