References to System.Object in base list aren't rewritten when type forwarded

[agocke]

Looks like we're not marking type forwards, and also not rewriting the typerefs. One of those has to change

[MichalStrehovsky]

We should go the rewrite route.

Interesting problem with that is that we might need to introduce tokens for things that didn't exist in the source assembly (e.g. apps don't normally refer to System.Private.CoreLib).

I think we will want to split off TokenBasedBasedNode into a base class that doesn't have a source token - i.e. we will have a base type that participates in writing (it has WriteInternal and BuildTokens), but doesn't have a metadata handle in the source assembly. We would need to figure out how to sort those. It should be easy enough for AssemblyRefs because we just sort alphabetically. These new tokens will show up differently in the tokenmap also. I don't have super clear design for it in my head yet. Maybe tokenmap doesn't even need to remember their exact token values; the node can remember it.

[vitek-karas]

If we want to support "Copy" assemblies, then we also have to deal with type forwarders. This doesn't prevent rewriting typerefs, it just means that typerefs in copy assemblies can't be rewritten and thus we need to be able to preserve the type forwarders they may point to.

[vitek-karas]

Just want to understand this a bit more:

• All type references which point to forwarders would be rewritten to point to implementation type
• Since type ref is a "namespace.name" + assembly reference, this can introduce new assembly references.
• Assembly references are really only used by type references (and potentially type forwarders)

So what if we:

• Change AssemblyReferenceNode to not be token based (as all the others) - instead it would extract all the relevant info from the token (if it's created from a token) and store it.
• Assembly ref nodes would not participate in token maps
• Before saving all assembly reference nodes would be somehow sorted and assigned tokens
• Then written out in that order - before anything else is written
• Type reference nodes would hold on to a reference to AssemblyReferenceNode they represent - when writing out, they would ask the AssemblyReferenceNode what is its handle, and use that to write itself.

Makes sense?

[MichalStrehovsky]

Yes, that could work. The "somehow sorted and assigned tokens" could be maybe done naturally, by:

• Add a new class SourceTokenBasedNode deriving from TokenBasedNode.
• Make all nodes that currently derive from TokenBasedNode to derive from SourceTokenBasedNode.
• Move the _handle field, the implementation of Write, BuildTokens and CompareTo to SourceTokenBasedNode
• Add an abstract Write, BuildTokens and CompareTo to TokenBasedNode.
• AssemblyReferenceNode would derive directly from TokenBasedNode. It's CompareTo would sort it after all the other nodes.
• The token will be acquired and remembered in BuildTokens.