Skip to main content

module analysis::typepal::ConfigurableScopeGraph

rascal-0.34.0
typepal-0.8.10

Usage

import analysis::typepal::ConfigurableScopeGraph;

Source code

http://github.com/usethesource/typepal/src/analysis/typepal/ConfigurableScopeGraph.rsc

Dependencies

extend analysis::typepal::Exception;
extend analysis::typepal::ISolver;
import IO;
import Set;
import Map;
import String;
extend ParseTree;

function defaultGetMinAType

AType defaultGetMinAType()

function defaultGetMaxAType

AType defaultGetMaxAType()

function defaultGetLub

AType defaultGetLub(AType atype1, AType atype2)

function defaultIsSubType

bool defaultIsSubType(AType atype1, AType atype2)

function defaultMayOverload

bool defaultMayOverload (set[loc] _, map[loc, Define] _)

function defaultInstantiateTypeParameters

AType defaultInstantiateTypeParameters(Tree _, AType def, AType ins, AType act, Solver _)

function defaultGetTypeNamesAndRole

tuple[list[str] typeNames, set[IdRole] idRoles] defaultGetTypeNamesAndRole(AType _)

function defaultGetTypeInNamelessType

AType defaultGetTypeInNamelessType(AType _, Tree _, loc _, Solver _)

function defaultGetTypeInTypeFromDefine

AType defaultGetTypeInTypeFromDefine(Define _, str _, set[IdRole] _, Solver _)

function defaultNormalizeName

str defaultNormalizeName(str s)

function defaultReportUnused

bool defaultReportUnused (loc _, TModel _)

data TypePalConfig

data TypePalConfig (       
Accept (loc def, Use use, Solver s) isAcceptableSimple
= defaultIsAcceptableSimple,
Accept (loc def, Use use, Solver s) isAcceptableQualified
= defaultIsAcceptableQualified,
Accept (loc defScope, loc def, Use use, PathRole pathRole, Solver s) isAcceptablePath
= defaultIsAcceptablePath
)
data TypePalConfig (
bool verbose = false,
bool logTime = false,
bool logSolverSteps = false,
bool logSolverIterations = false,
bool logAttempts = false,
bool logTModel = false,
bool validateConstraints = true,

AType() getMinAType
= AType (){ throw TypePalUsage("`getMinAType()` called but is not specified in TypePalConfig"); },

AType() getMaxAType
= AType (){ throw TypePalUsage("`getMaxAType()` called but is not specified in TypePalConfig"); },

bool (AType t1, AType t2) isSubType
= bool (AType atype1, AType atype2) { throw TypePalUsage("`subtype(<atype1>, <atype2>)` called but `isSubType` is not specified in TypePalConfig"); },

AType (AType t1, AType t2) getLub
= AType (AType atype1, AType atype2){ throw TypePalUsage("`lub(<atype1>, <atype2>)` called but `getLub` is not specified in TypePalConfig"); },

bool (set[loc] defs, map[loc, Define] defines) mayOverload
= bool (set[loc] _, map[loc, Define] _) { return false; },

bool (IdRole idRole) isInferrable
= bool(IdRole _) { return false; },

str(str) normalizeName
= str (str s) { return replaceAll(s, "\\", ""); },

AType (Tree selector, AType def, AType ins, AType act, Solver s) instantiateTypeParameters
= AType(Tree _, AType _, AType _, AType act, Solver _){ return act; },

tuple[list[str] typeNames, set[IdRole] idRoles] (AType atype) getTypeNamesAndRole
= tuple[list[str] typeNames, set[IdRole] idRoles](AType _){
throw TypePalUsage("`useViaType` used without definition of `getTypeNamesAndRole`");
},

AType (Define containerDef, str selectorName, set[IdRole] idRolesSel, Solver s) getTypeInTypeFromDefine
= AType (Define _, str _, set[IdRole] _, Solver _) { throw NoBinding(); },

AType(AType containerType, Tree selector, loc scope, Solver s) getTypeInNamelessType
= AType(AType _, Tree _, loc _, Solver _){
throw TypePalUsage("`useViaType` used without definition of `getTypeInNamelessType`");
},

TModel(map[str,Tree] namedTrees, TModel tm) preSolver = TModel(map[str,Tree] _, TModel tm) { return tm; },
void (map[str,Tree] namedTrees, Solver s) postSolver = void(map[str,Tree] _, Solver _) { return ; },

bool(loc def, TModel tm) reportUnused = defaultReportUnused
)

data Accept

data Accept  
= acceptBinding()
| ignoreContinue()
| ignoreSkipPath()
;

function defaultIsAcceptableSimple

Accept defaultIsAcceptableSimple(loc candidate, Use use, Solver _)

function defaultIsAcceptablePath

Accept defaultIsAcceptablePath(loc defScope, loc def, Use use, PathRole _, Solver _)

function defaultIsAcceptableQualified

Accept defaultIsAcceptableQualified(loc _, Use _, Solver _)

function checkPaths

default bool checkPaths(TModel tm, loc from, loc to, PathRole pathRole, bool(TModel,loc) pred)

function existsPath

bool existsPath(TModel tm, loc from, loc to, PathRole pathRole)

data ScopeGraph

data ScopeGraph  
= scopegraph(
set[loc] (Use u) lookup,
void (Solver s) setSolver
)
;

function newScopeGraph

ScopeGraph newScopeGraph(TModel tm, TypePalConfig config)