eu.bandm.tools.d2d2.base

Class Resolver3

java.lang.Object

eu.bandm.tools.d2d2.model.MATCH_ONLY_00

eu.bandm.tools.d2d2.model.Rewrite

eu.bandm.tools.d2d2.base.Resolver3

All Implemented Interfaces:

Rewriter

public class Resolver3
extends Rewrite

Transforms a "raw" module into an "instantiated" one. Usage: create a new object of this class for one top level raw module and call resolveAllPublics().
The resulting resolvedModule ist self-contained: All Definitions rewritten from imported modules are cloned to definitions contained directly therein; as NAME they get the original name prepended by the complete import prefix path.
The overall control flow is roughly as follows:

    resolveAllPublics()
     |      |
     |      |
     V      
    createNewInstance(..)
   ^   V
  /    Clone the definition object,
 |     Call rewriting match(..) for the 
 |      RegExp = def.value.
 |         |   |   |        
 |         V   |   |
 |         action(Subst/Insertion)
 |         =update rewriting contexts
 |             V   |
 |             rewriteFields([div. constructors])
 |             =rewrite expression objects, filling
 |              fields with rewrite of sub-expr
 |                 V
 |                 rewriteFields(Reference)
 |                 () Apply local rewrites and
 |                    visit target expression recursively
 |                 () or else apply import level rewrites 
 |                    and visit target expr. recursively
 |                 () or else restore "frozen @" replacement context
 |                    and visit again.
 |                 () otherwise: 
 |                        |
 |                        V
 |                       visitPossiblyImportedDef(..)
 |                        V  |
 |                       loadImportedModule()
 |                           V
 |                           visitDefinition(..)
 |                           () if instance for this combination (of rawDef and importContext)
 |                              does NOT exist:
 |                                 create a new Instance and start its rewriting.
 |                                 on return: if ".cyclic" is not set: set ".complete"
 |                           // now an instance exists:
 |                           () if instance is not "bound()": memorize a classifcation request
 |                           () if !.complete and insert mode then set .cyclic
 |                           () if insertMode && !cyclic: rewrite reference to 
 |                                                rewritten contents/expression
 |                           () if insertMode && cyclic: rewrite reference to 
 |                                    "@ x" combination, "x" the rewritten definition
 |                           () else store rewritten instance as reference's ".resolved"
 |                           (The results are stored in two maps : 
 |                                   "reference2rawDef" and "reference2importContext".)
 |          |       
 |          |       
 |          |       
 |          |
  \         V
   \     processWaitingReferences()
    \    V
     \ ->processWaitingReference(..)
     /\     creates a new Instance object, which
    /  \    is either its own class, or related to another 
   /    \   Instance of the same raw def as its representative
  /      \  (hypothetically or confirmed).
  |       \ |     |
  |        \V     |
  |         createNewInstance(..)
  |               V
  |               equivalent(ref's def, old instantiation of same def)
  |               V
  |               (new Equivalence()).match()
  \                   V
   \                  descend(Reference)
    \----------------                 
 
 
  

Central object is Resolver3.Instance which is built for every found combination of Definition and Resolver3.ImportContext. (Additionally Instances will be needed for combinations of local substitution, insert operation and recursive call as in "@x^(a/b)" with "x=...x...". This is done by the methods createNewInstance(ImportContext,Definition,Reference) and newHypothesis(Instance). The former also does the CLONING of the Definition object and the rewriting of the expression. (The latter only creates a new Instance object reflecting the hypothesis of being equivalent with the method's argument.)
First all public definitions from the top-level raw module are given one Resolver3.Instance, which is an "equivalence class", i.e. its own representative. During this, each expression value is visited with the rewriting method of this class, and all rewriting directives (local and coming with module imports) are applied. As a result, all reached References are attributed by the maps reference2rawDef and reference2importContext, reflecting the result of applying all rewrite directives.
Every Resolver3.Instance is addressed globally by a "characteristic pair" of raw definition and import context. Additionally a reached reference is entered in the set waitingForEquivalence, iff there is no Resolver3.Instance yet for this combination, or only one with a failed hypothesis.
In the second phase this set is emptied one-by-one by processWaitingReference(Reference):
If for the characteristic pair of the reference a "bound()" Resolver3.Instance exists, nothing is done.
Otherwise an Resolver3.Instance is created. Every already existing Resolver3.Instance for the same raw definition, which is an equivalence class, i.e. its own representative, is tested against the import context of the critical reference by calling equivalent(Definition,Definition).
As soon as one such call succeeds, Instance.hypothesisConfirmed() is called on this hypothesis, making it a permanent fact.
If this does not happen, the new Instance is made its own class by Instance.setIsClass().
The equivalence test implemented by the class Resolver3.Equivalence goes from the two definitions to the two expressions, and visits them pairwise.
Failure is signalled by throwing the local Exception Resolver3.DifferenceFound.
As soon as the two constructors of the compared expression sub-tree are not identical, a failure is found.
The same holds vor un-equal constant values.
When two References are reached, first processWaitingReference(Reference) is called for both of them recursively, and then the representatives of the two resulting Instance objects are compared.
The Resolver3.Instance which is currently under test against some equivalence class has been stored in currentHypothesis. So, whenever an Resolver3.Instance (=x) is reached which is itself hypothetical, the dependency is memorized by adding "currentHypothesis" to "x.requiredBy" and setting "currentHypothesis.requires=true" (This is for optimization /object reuse only).
Whenever a hypothesis fails, the failure is propagated to all in its ".requiredBy" set, and the representing Reference (from Resolver3.Instance.reprRef is re-entered into waitingForEquivalence.







TESTS as with 20160826:

d2d2/test> make expand MODULE=basic.deliverables
(( ALTE VBERSION !?!)) d2d2/test/basic.deliverables.expanded 853 lines without equivalence.
d2d2/test/EXPANDED_basic.deliverables 998 line with equivalence.
d2d2/test> make expand MODULE=d2d-meta

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected class	Resolver3.Binding<T> Stack frame which memorizes a particular single rewriting clause, mapping an identifier to an expression.
protected class	Resolver3.DifferenceFound
class	Resolver3.DistributeSolutions Adjusts alle reachable references to point to the representative of its equivalence class: by the pointer ".resolved" to the rewritten Definition object, as well as by "sourceText" to the compound name.
protected class	Resolver3.Equivalence
protected class	Resolver3.FlattenContext Stack frame which memorizes the situation when parsing an "insert operator" = "@".
static class	Resolver3.Formatter_showingResolution
protected class	Resolver3.ImportContext Stack frames which represent dynamic import situations.
protected class	Resolver3.Instance The parametrized instance of one particular d2d model Definition.

Field Summary

Fields

Modifier and Type	Field and Description
protected @Opt String	currentDefinitionName The name of the definition (local to its containing module), the expression of which is currently rewritten.
protected Resolver3.FlattenContext	currentFlattenContext Top of the stack of Resolver3.FlattenContexts.
protected @Opt ImportItem	currentLexicalImportItem The ImportItem when an expression is rewritten like "a" in "import A from modA ^(a/b)".
protected Resolver3.Binding<Expression>	currentLocalSubsts Stack of bindings representing the nesting of local substitution expressions of form exp^(a/b).
protected Resolver3.DifferenceFound	differenceFound
protected CheckedMap_RD<String,Definition>	emptyLocals A constant map which contains NO local definitions, used as the value of "localDefs" when a definition is cloned/instantiated.
protected Resolver3.ImportContext	importContextForDefs Where to look for the definition, meant by some particular reference value.
protected Resolver3.ImportContext	importContextForRews Where to look for rewrite instructions coming with the "ImportItem", when rewriting references.
protected Map<Definition,Map<Resolver3.ImportContext,Resolver3.Instance>>	instances Maps indexed by the raw (=source level) definitions.
protected ModuleRegistry	moduleRegistry Where imported raw modules are loaded from.
protected MessageTee<SimpleMessage<XMLDocumentIdentifier>>	msg
protected MessageCounter<SimpleMessage<XMLDocumentIdentifier>>	msgcount
protected Map<Reference,Resolver3.ImportContext>	reference2importContext Central result of the rewriting process, which maps rewritten Reference objects to the import context (=module import prefix chain=rewriting context) of the finally meant definition.
protected Map<Reference,Definition>	reference2rawDef Central result of the rewriting process, which maps rewritten Reference objects to the definition in the "raw" source module which is meant.
protected ResolvedModule	resolvedModule Output data: the result of the resolution process.
protected Resolver3.ImportContext	rootImportContext A synthetic/pseudo import context, to fulfill the role of "importContext" for the top-level module, which is indeed NOT imported.
protected Module	rootModule Input data: the source module to be resolved.
static String	rootModuleExpandedSuffix
static String	rootModuleSymbolicName
protected boolean	unify Whether unification shall be used for minimization of instantiated definitions.
protected Set<Reference>	waitingForEquivalence Set of all references which have not yet been classified for equivalence.

Fields inherited from class eu.bandm.tools.d2d2.model.Rewrite

cache, mcache, original

Fields inherited from class eu.bandm.tools.d2d2.model.MATCH_ONLY_00

_visitor_debug_stream, partial

Constructor Summary

Constructors

Constructor and Description
Resolver3(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msgoutput, ModuleRegistry moduleRegistry, Module rootModule) Central service providing method.

Method Summary

Modifier and Type	Method and Description
void	action(Insertion ins) Insert a new Resolver3.FlattenContext on top of the stack of flatten contexts, then descend into the sub-expression.
void	action(Perm x)
void	action(Subst subst) Simply insert a new Resolver3.Binding on top of the stack of local substs, then descend into the sub-expression.
protected Resolver3.Instance	createNewInstance(Resolver3.ImportContext ic, Definition raw, @Opt Reference reprRef) Central routine for processing a new instantiation of a particular definition in a particular import context. In case of XRegExp: Calls the main class visitor methods for applying all rewriting expressions to the def's value.
void	dumpInstances()
protected boolean	equivalent(Definition def1, Definition def2)
protected boolean	equivalent(Expression exp1, Expression exp2)
protected void	error(Location<XMLDocumentIdentifier> loc, String txt, Object... obj)
protected <T> @Opt Resolver3.Binding<T>	findBinding(@Opt Resolver3.Binding<T> binding, String id) Is called with currentLocalSubsts; iterate through the chain of Resolver3.Binding.
protected @Opt Resolver3.Instance	findInstance(Definition raw, Resolver3.ImportContext ic)
protected Map<Resolver3.ImportContext,Resolver3.Instance>	findInstances(Definition raw)
protected @Opt Resolver3.ImportContext	loadImportedModule(Location<XMLDocumentIdentifier> loc, Resolver3.ImportContext ic, String pref) Load the imported module referred to in the ImportItem with the given name, and create and store a new Resolver3.ImportContext, if not yet done.
protected Resolver3.Instance	processWaitingReference(Reference ref) Process one reference which has not yet been classified, but already been resolved (i.e.
protected void	processWaitingReferences() Main service provider entry point to process all reachable references.
@Opt Module	resolveAllPublics() Central service providing method.
@Opt Module	resolveAllPublics(boolean unify) Central service providing method.
protected void	rewriteFields(Alt clone) Rewrite all sub-expessions; propagate "all are empty" upwards, or replace singleton-alternative by its only member.
protected void	rewriteFields(CharBinary clone) Rewrite all sub-expessions; propagate "all are empty" upwards, or replace singleton expression by its only member.
protected void	rewriteFields(CharSetConst clone) Simply clones.
protected void	rewriteFields(GrUnary clone) Rewrite the sub-expression; propagate "empty" upwards.
protected void	rewriteFields(ParseParticle clone) Rewrite sub-expression and propagate "empty" upwards.
protected void	rewriteFields(Perm clone) Rewrite all sub-expessions; propagate "all are empty" upwards, or replace singleton-permutation by its only member.
void	rewriteFields(Reference ref) Central rewriting method: for one particular reference, apply local rewrite, module import rewrite and inlining-expansion, in this sequential order.
protected void	rewriteFields(Seq clone) Rewrite all sub-expessions; propagate "all are empty" upwards, or replace singleton-sequence by its only member.
protected void	rewriteFields(StringConst clone) Simply clones.
protected void	switchModuleRest(Location<XMLDocumentIdentifier> loc, String... prefs) Skip the first id in compound id, since it has just been processed and caused a module import context switch, and continue to resolve the rest, if any.
protected void	visitDefinition(Location<XMLDocumentIdentifier> loc, String... prefs) We are currently rewriting a reference (the on-stock produced clone is currentReference) and resolving it, and have finally applied all rewritings of all levels and reached a reference text, one identifier or more than one identifiers, joined by Chars.STRING_NAMING_LEVEL_SEPARATOR.
protected void	visitPossiblyImportedDefinition(Location<XMLDocumentIdentifier> loc, String... prefs) After all substitutions have been applied: find the source text meant by a reference.
protected void	visitPossiblyImportedDefinition(Location<XMLDocumentIdentifier> loc, String id)
protected void	warning(Location<XMLDocumentIdentifier> loc, String txt, Object... obj)

Methods inherited from class eu.bandm.tools.d2d2.model.Rewrite

action, action, action, action, action, action, action, action, action, action, action, action, action, action, action, action, action, action, action, action, action, action, action, action, action, action, action, action, action, action, action, action, action, action, action, breakLoop, breakLoop, breakLoop, breakLoop, breakLoop, getResult, isMulti, lookUp, putToCache, revert, rewrite_typed, rewrite, rewriteFields, rewriteFields, rewriteFields, rewriteFields, rewriteFields, rewriteFields, rewriteFields, rewriteFields, rewriteFields, rewriteFields, rewriteFields, rewriteFields, rewriteFields, rewriteFields, rewriteFields, rewriteFields, rewriteFields, rewriteFields, rewriteFields, rewriteFields, rewriteFields, rewriteFields, rewriteFields, rewriteFields, rewriteFields, rewriteFields, rewriteFields, rewriteFields, rewriteFields, substitute_empty, substitute, useCache

Methods inherited from class eu.bandm.tools.d2d2.model.MATCH_ONLY_00

_visitor_trace, action, action, action, action, foreignObject, match, match, match, match, match, match, match, match, match, match, match, match, match, match, match, match, match, match, match, match, match, match, match, match, match, match, match, match, match, match, match, match, match, match, match, match, match, match, match, nomatch

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

msg

protected final MessageTee<SimpleMessage<XMLDocumentIdentifier>> msg

msgcount

protected final MessageCounter<SimpleMessage<XMLDocumentIdentifier>> msgcount

moduleRegistry

protected final ModuleRegistry moduleRegistry

Where imported raw modules are loaded from.

rootModule

protected final Module rootModule

Input data: the source module to be resolved.

rootImportContext

protected final Resolver3.ImportContext rootImportContext

A synthetic/pseudo import context, to fulfill the role of "importContext" for the top-level module, which is indeed NOT imported.

resolvedModule

protected final ResolvedModule resolvedModule

Output data: the result of the resolution process.

unify

protected boolean unify

Whether unification shall be used for minimization of instantiated definitions. Is set to false ONLY FOR TEST AND DEBUG purposes.

rootModuleSymbolicName

public static final String rootModuleSymbolicName

See Also:

Constant Field Values

rootModuleExpandedSuffix

public static final String rootModuleExpandedSuffix

See Also:

Constant Field Values

emptyLocals

protected final CheckedMap_RD<String,Definition> emptyLocals

A constant map which contains NO local definitions, used as the value of "localDefs" when a definition is cloned/instantiated.

currentLocalSubsts

protected Resolver3.Binding<Expression> currentLocalSubsts

Stack of bindings representing the nesting of local substitution expressions of form exp^(a/b).

importContextForRews

protected Resolver3.ImportContext importContextForRews

Where to look for rewrite instructions coming with the "ImportItem", when rewriting references. Is initially set up by createNewInstance(ImportContext,Definition,Reference) to the definition's import context, before starting the rewrite of the definitions's expression.
Whenever such a substitution expression is found and before it is visited, the value of this variable it is set to the import context of that expression, which is the ".predec" of the current value ( =^= the ImportItem to evaluate), because only in this context the expressions can (in the current implementation) be interpreted.
Whenever a definition is inlined (= its expression is visited, due to an @ operator), then this variable is re-adjusted for the duration of this visit to the current value of importContextForDefs, where that definition has been found.
Whenever a frozen Resolver3.FlattenContext is applied to a reference, it is among the reconstructed context state. (This is the only situation when it differs from importContextForDefs, because a verbatim, non-rewritten reference to a definition is meant in the same ImportContext as the original definition currently under flattening, not in the ImportContext containing the "@ A.B.x" statement.)

importContextForDefs

protected Resolver3.ImportContext importContextForDefs

Where to look for the definition, meant by some particular reference value. Esp. in the case this reference is NOT rewritten, but meant in the same context as the containing definition. Is initially set up by createNewInstance(ImportContext,Definition,Reference) to the definition's import context.
Is advanced through the chain of import prefixes when visitPossiblyImportedDefinition(Location, String...) resolves the import prefices.
FIXME WEITERMACHEN +++

currentDefinitionName

@Opt
protected @Opt String currentDefinitionName

The name of the definition (local to its containing module), the expression of which is currently rewritten. Is only used to select the local substitution requests of form "import A from modA IN DEFNAME ^(a/b)". Must be ==null whenever an expression is rewritten which is NOT in a definition, but in a module import rewriting.

currentLexicalImportItem

@Opt
protected @Opt ImportItem currentLexicalImportItem

The ImportItem when an expression is rewritten like "a" in "import A from modA ^(a/b)". Must be ==null whenever an expression is rewritten which not in such a rewrite expression but in a definition. 20181024 NOT NEEDED (war nur fürs name mangling bei "a/b^@c" ANGEDACHT !?!?)

currentFlattenContext

protected Resolver3.FlattenContext currentFlattenContext

Top of the stack of Resolver3.FlattenContexts. Pushed onto when an insert operator is rewritten; popped from (in two steps) when a Reference is reached by this Rewriter and all other rewrite directives do not match.

instances

protected Map<Definition,Map<Resolver3.ImportContext,Resolver3.Instance>> instances

Maps indexed by the raw (=source level) definitions. Accessed only for reading by findInstances(Definition) and by findInstance(Definition, ImportContext); written only by createNewInstance(ImportContext,Definition,Reference).

reference2rawDef

protected Map<Reference,Definition> reference2rawDef

Central result of the rewriting process, which maps rewritten Reference objects to the definition in the "raw" source module which is meant. FINALLY via DistributeSolutions the results are entered into ".resolved"

reference2importContext

protected Map<Reference,Resolver3.ImportContext> reference2importContext

Central result of the rewriting process, which maps rewritten Reference objects to the import context (=module import prefix chain=rewriting context) of the finally meant definition. FINALLY via Resolver3.DistributeSolutions the results are entered into ".resolved"

waitingForEquivalence

protected Set<Reference> waitingForEquivalence

Set of all references which have not yet been classified for equivalence. Is filled by createNewInstance(ImportContext,Definition,Reference) visitDefinition(Location,String...). ((FIXME REALLY !?!??))

differenceFound

protected final Resolver3.DifferenceFound differenceFound

Constructor Detail

Resolver3

public Resolver3(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msgoutput,
                 ModuleRegistry moduleRegistry,
                 Module rootModule)

Central service providing method. Create a new instance for one particular raw root module. Afterwards resolveAllPublics() must be called. (Can only by used once.)

Method Detail

resolveAllPublics

@Opt
public @Opt Module resolveAllPublics()

Central service providing method.

Returns:

a copy of the top module with all references replaced by references to resolved definitions. Returns null in case of error.

resolveAllPublics

@Opt
public @Opt Module resolveAllPublics(boolean unify)

Central service providing method.

Returns:

a copy of the top module with all references replaced by references to resolved definitions. Returns null in case of error.

error

protected void error(Location<XMLDocumentIdentifier> loc,
                     String txt,
                     Object... obj)

warning

protected void warning(Location<XMLDocumentIdentifier> loc,
                       String txt,
                       Object... obj)

findBinding

@Opt
protected <T> @Opt Resolver3.Binding<T> findBinding(@Opt
                                                         @Opt Resolver3.Binding<T> binding,
                                                         String id)

Is called with currentLocalSubsts; iterate through the chain of Resolver3.Binding.

Returns:

the first one which maps "id", or null if none is found.

dumpInstances

public void dumpInstances()

findInstances

protected Map<Resolver3.ImportContext,Resolver3.Instance> findInstances(Definition raw)

findInstance

@Opt
protected @Opt Resolver3.Instance findInstance(Definition raw,
                                                    Resolver3.ImportContext ic)

createNewInstance

protected Resolver3.Instance createNewInstance(Resolver3.ImportContext ic,
                                               Definition raw,
                                               @Opt
                                               @Opt Reference reprRef)

Central routine for processing a new instantiation of a particular definition in a particular import context.
In case of XRegExp: Calls the main class visitor methods for applying all rewriting expressions to the def's value. (During this, more References may be added to waitingForEquivalence.)
Additionally memorizes/reifies all context values into the one single returned Resolver3.Instance object.
Sets up the state machine for the later classification process.
State of the state machine when returning: isClass, hypothetical, falsified, requires are all false; representative is null.
Is called for top-level classes, and "isClass" is set immediately.
Is called during processWaitingReference(Reference) and NOT made own class, but first made hypothetically equivalent with all other class-like instances first.
NEW hypotheses (of being equivalent with another class instance) are created by newHypothesis(Instance), possibly reusing the object structure physically.

action

public void action(Subst subst)

Simply insert a new Resolver3.Binding on top of the stack of local substs, then descend into the sub-expression. Remove the binding on return.

Overrides:

action in class Rewrite

action

public void action(Insertion ins)

Insert a new Resolver3.FlattenContext on top of the stack of flatten contexts, then descend into the sub-expression. Remove the binding on return.

Overrides:

action in class Rewrite

rewriteFields

protected void rewriteFields(GrUnary clone)

Rewrite the sub-expression; propagate "empty" upwards.

Overrides:

rewriteFields in class Rewrite

rewriteFields

protected void rewriteFields(Alt clone)

Rewrite all sub-expessions; propagate "all are empty" upwards, or replace singleton-alternative by its only member.

Overrides:

rewriteFields in class Rewrite

rewriteFields

protected void rewriteFields(Perm clone)

Rewrite all sub-expessions; propagate "all are empty" upwards, or replace singleton-permutation by its only member.

Overrides:

rewriteFields in class Rewrite

rewriteFields

protected void rewriteFields(Seq clone)

Rewrite all sub-expessions; propagate "all are empty" upwards, or replace singleton-sequence by its only member.

Overrides:

rewriteFields in class Rewrite

rewriteFields

protected void rewriteFields(CharBinary clone)

Rewrite all sub-expessions; propagate "all are empty" upwards, or replace singleton expression by its only member.

Overrides:

rewriteFields in class Rewrite

rewriteFields

protected void rewriteFields(ParseParticle clone)

Rewrite sub-expression and propagate "empty" upwards.

Overrides:

rewriteFields in class Rewrite

rewriteFields

protected void rewriteFields(CharSetConst clone)

Simply clones.

Overrides:

rewriteFields in class Rewrite

rewriteFields

protected void rewriteFields(StringConst clone)

Simply clones.

Overrides:

rewriteFields in class Rewrite

action

public void action(Perm x)

Overrides:

action in class Rewrite

rewriteFields

public void rewriteFields(Reference ref)

Central rewriting method: for one particular reference, apply local rewrite, module import rewrite and inlining-expansion, in this sequential order.

Overrides:

rewriteFields in class Rewrite

visitPossiblyImportedDefinition

protected void visitPossiblyImportedDefinition(Location<XMLDocumentIdentifier> loc,
                                               String id)

See Also:

visitPossiblyImportedDefinition(Location,String...)

visitPossiblyImportedDefinition

protected void visitPossiblyImportedDefinition(Location<XMLDocumentIdentifier> loc,
                                               String... prefs)

After all substitutions have been applied: find the source text meant by a reference. This can be a compound identifier, and its first component MAY be an import prefix. If not, call visitDefinition(Location, String...).
Else an import must be processed: First resolve the chain of "module import substitutions". Then load the required raw module. Do so until the start of the name of a definition is reached (i.e. head of id-list is not an import key). This chain is cycle-free by construction. In sync with this resolution: update the global variable importContextForDef and the caches of loaded raw modules.

switchModuleRest

protected void switchModuleRest(Location<XMLDocumentIdentifier> loc,
                                String... prefs)

Skip the first id in compound id, since it has just been processed and caused a module import context switch, and continue to resolve the rest, if any.

loadImportedModule

@Opt
protected @Opt Resolver3.ImportContext loadImportedModule(Location<XMLDocumentIdentifier> loc,
                                                               Resolver3.ImportContext ic,
                                                               String pref)

Load the imported module referred to in the ImportItem with the given name, and create and store a new Resolver3.ImportContext, if not yet done.

Parameters:

ic - the import context from which the module is imported

pref - the source text prefix of the import.

visitDefinition

protected void visitDefinition(Location<XMLDocumentIdentifier> loc,
                               String... prefs)

We are currently rewriting a reference (the on-stock produced clone is currentReference) and resolving it, and have finally applied all rewritings of all levels and reached a reference text, one identifier or more than one identifiers, joined by Chars.STRING_NAMING_LEVEL_SEPARATOR.
prefs[0] is NOT in import items key set, so we expect a Definition in the module addressed by the GLO IN variable importContextForDefs.

processWaitingReferences

protected void processWaitingReferences()

Main service provider entry point to process all reachable references. It picks an arbitrary entity from waitingForEquivalence and calls processWaitingReference(Reference). Processing means resolving all substitutions and classifying the adressed (rewritten) Definition into equivalence classes.
That pool of unprocessed references is filled by #createNewInstance(ImportContext,Definition.Reference), namely when visiting the definion's expression. This is called initially by resolveAllPublics(boolean) and recursively during processing by processWaitingReference(Reference).

processWaitingReference

protected Resolver3.Instance processWaitingReference(Reference ref)

Process one reference which has not yet been classified, but already been resolved (i.e. reference2rawDef and reference2importContext have been set, etc.)
If it has assigned an Resolver3.Instance object (which is not a failed hypothesis) then do nothing. Otherwise test equivalence with all Instances of the same raw definition, which are own equivalence classes. For this, a hypothetical equivalence is constructed and equivalent(Definition,Definition) is called. If this succeeds, the hypothesis is confirmed. If all these fail, the Instance is made an equivalence class on its own.

equivalent

protected boolean equivalent(Definition def1,
                             Definition def2)

equivalent

protected boolean equivalent(Expression exp1,
                             Expression exp2)