Module marked with ModuleSuffix attribute is hidden by another module with the same name

[vasily-kirichenko]

If a project contains two modules with the same name, one of which is marked with ModuleSuffix attribute:

// Foo1.fs
namespace Library

[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
module Foo =
    let bar x = x

// Foo2.fs
module Library.Foo

let buzz x = x

symbols defined in the marked with ModuleSuffix attribute one are not seen in projects referencing this one:

The bug (feature?) was found while moving ExtCore library to .NET Standard 2.0

Minimal repro https://github.com/vasily-kirichenko/TwoModulesBug

It's compiled to (ILSpy):

namespace Library
{
	[CompilationMapping(SourceConstructFlags.Module)]
	public static class Foo
	{
		public static a buzz<a>(a x)
		{
			return x;
		}
	}
}

namespace Library
{
	[CompilationMapping(SourceConstructFlags.Module), CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)]
	public static class FooModule
	{
		public static a bar<a>(a x)
		{
			return x;
		}
	}
}

[dsyme]

I suppose this should work - I'm somewhat surprised it doesn't, so the fix may be fairly simple.

[vasily-kirichenko]

Interesting that the code does not compile if the both modules are defined in the same file:

[abelbraaksma]

FWIW, I tried your examples in VS2015 w/ F# 4.0:

• Having them in the same file gives the same conflict with modules
• Having them in the same file but with module and type mixed behaves differently (see below)
• Having them in separate files does not shadow the module (regardless of order, i.e. if the module-suffix module is defined before or after the one without).

Here, VS2015, with the ModuleSuffix being defined in a file prior to this definition:

Note that when you mix type and module (as opposed to two module defs), the behavior depends. I.e. this throws the error (but surprisingly, IntelliSense finds the method Foo.buzz correctly):

But this doesn't:

Finally, if we take the specification on this, we find that the text at least suggests that all these examples should work, but specifically only talks about type + module, not module + module. Which is interesting, since the documentation on the same subject talks about namespace + module nameconflicts, which is not mentioned in the spec.

[vasily-kirichenko]

@abelbraaksma thanks for the investigation. The bug does not exist in F# 4.0 for sure because ExtCore library was successfully compiled.

[dsyme]

@vasily-kirichenko Thanks - I hadn't realised this was a regression