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

		public static TypeSpec IsImportedTypeOverride (TypeSpec ts, TypeSpec found)
		{
			var ts_accessible = (ts.Modifiers & Modifiers.PUBLIC) != 0 || ts.MemberDefinition.IsInternalAsPublic (RootContext.ToplevelTypes.DeclaringAssembly);
			var found_accessible = (found.Modifiers & Modifiers.PUBLIC) != 0 || found.MemberDefinition.IsInternalAsPublic (RootContext.ToplevelTypes.DeclaringAssembly);

			if (ts_accessible && !found_accessible)
				return ts;

			// found is better always better for accessible or inaccessible ts
			if (!ts_accessible)
				return found;

			return null;
		}

        FullNamedExpression Lookup(string name, int arity, LookupMode mode, Location loc)
        {
            //
            // Check whether it's in the namespace.
            //
            FullNamedExpression fne = ns.LookupTypeOrNamespace(this, name, arity, mode, loc);

            //
            // Check aliases.
            //
            if (using_aliases != null && arity == 0)
            {
                foreach (NamespaceUsingAlias ue in using_aliases)
                {
                    if (ue.Alias == name)
                    {
                        if (fne != null)
                        {
                            if (Doppelganger != null)
                            {
                                if (mode == LookupMode.Normal)
                                {
                                    // 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)
            {
                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(this, name, arity, mode, 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;
                }

                // It can be top level accessibility only
                var better = Namespace.IsImportedTypeOverride(module, texpr_match.Type, texpr_fne.Type);
                if (better == null)
                {
                    if (mode == LookupMode.Normal)
                    {
                        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);
        }