Type System Base Class: Module type_system

These classes provide the type system mechanism.

class pyrser.type_system.TypeName(value)

Bases: str

__eq__(self, oth) → bool

__hash__(self) → int

__init__(self, value)

__lt__(self, oth) → bool

__str__(self) → str

get_subcomponents(self) → list

is_polymorphic

Check if one of composed type name is poly

class pyrser.type_system.Symbol(name, parent=None)

Bases: object

Symbol are semantic name used in a language. Could be map to binary symbol but conceptually are more related to language symbol table.

__getstate__(self)

For pickle don’t handle weakrefs...

__init__(self, name, parent= None)

__repr__(self) → str

__str__(self) → str

get_parent(self) → object

Auto deref parent and return the instance.

get_scope_list(self) → list

Return the list of all contained scope from global to local

get_scope_names(self) → list

Return the list of all contained scope from global to local

internal_name(self) → str

Returns the namespace’s internal_name.

set_parent(self, parent) → object

show_name(self) → str

Return a convenient name for type checking

class pyrser.type_system.Signature(name: str)

Bases: pyrser.type_system.symbol.Symbol

Describe a function or variable signature for the language

__init__(self, name: str)

__str__(self) → str

class pyrser.type_system.EvalCtx(sig: pyrser.type_system.signature.Signature)

Bases: object

Store environment for mono/poly call.

__init__(self, sig: Signature)

__len__(self) → int

__str__(self) → str

compute_tret

from_sig(sig: Signature) → object

get_compute_sig(self) → Signature

Compute a signature Using resolution!!!

TODO: discuss of relevance of a final generation for a signature

get_parent(self)

get_resolved_names(self, type_name: TypeName) → list

Use self.resolution to subsitute type_name. Allow to instanciate polymorphic type ?1, ?toto

internal_name(self)

is_polymorphic

name

resolve(self)

Process the signature and find definition for type.

set_parent(self, parent) → object

When we add a parent (from Symbol), don’t forget to resolve.

set_resolved_name(self, ref: dict, type_name2solve: TypeName, type_name_ref: TypeName)

Warning!!! Need to rethink it when global poly type

show_name(self)

tparams

tret

use_translator(self, translator)

Attach a translator to an EvalCtx to convert output of the function into another type

use_variadic_types(self, list_type)

Attach a list of types for extra variadic argument of a call

values(self) → list

Make EvalCtx iterable (to update a scope with it)

variadic

class pyrser.type_system.Scope(name: str=None, sig: [<class 'pyrser.type_system.signature.Signature'>]=None, state=0, is_namespace=True)

Bases: pyrser.type_system.symbol.Symbol

Scope of Signature for a Scope/namespace/type etc... Basic abstraction of type checking. Scope is not a ‘pure’ python set but something between a set and a dict...

_Scope__update_count(self)

Update internal counters

__and__(self, sig: Scope) → Scope

& operator

__contains__(self, s: Signature) → bool

check if a Signature or a Type is declared in a Scope

__getstate__(self)

For pickle, we don’t handle weakrefs...

__iand__(self, sig: Scope) → Scope

&= operator

__init__(self, name: str= None, sig= None, state= 0, is_namespace= True)

Unnamed scope for global scope

A Scope have basically 3 possibles states:

FREE: it’s a standalone Scope, generally the global Scope LINKED: the Scope is related to another Scope for type resolution,

like compound statement

EMBEDDED: the Scope was added into another Scope,

it forwards all ‘in’ calls...like namespacing

A Scope could or couldn’t act like a namespace. All Signature added into a ‘namespaced’ Scope was prefixed by the Scope name.

__ior__(self, sig: list) → Scope

|= operator

__isub__(self, sig: Scope) → Scope

-= operator

__ixor__(self, sig: Scope) → Scope

^= operator

__len__(self) → int

Len of the Set

__or__(self, sig: Scope) → Scope

operator

__repr__(self) → str

Internal representation

__str__(self) → str

__sub__(self, sig: Scope) → Scope

• operator

__xor__(self, sig: Scope) → Scope

^ operator

add(self, it: Signature) → bool

Add it to the Set

addTranslator(self, val: Translator, as_global= False)

addTranslatorInjector(self, ast_method)

Could be redefine in a subscope

callInjector(self, old: Node, trans: Translator) → Node

If don’t have injector call from parent

clear(self) → bool

Clear all signatures in the Set

count_funs(self) → int

Count function define by this scope

count_types(self) → int

Count subtypes

count_vars(self) → int

Count var define by this scope

difference(self, sig: Scope) → Scope

Create a new Set produce by a Set subtracted by another Set

difference_update(self, oset: Scope) → Scope

Remove values common with another Set

discard(self, it: Signature) → bool

Remove it only if present

findTranslationTo(self, t2: str)

Find an arrow (->) aka a function able to translate something to t2

first(self) → Signature

Retrieve the first Signature ordered by mangling descendant

get(self, key: str, default= None) → Signature

Get a signature instance by its internal_name

get_all_polymorphic_return(self) → bool

For now, polymorphic return type are handle by symbol artefact.

–> possible multi-polymorphic but with different constraint attached!

get_by_params(self, params)

Retrieve a Set of all signature that match the parameter list. Return a pair:

pair[0] the overloads for the functions pair[1] the overloads for the parameters

(a list of candidate list of parameters)

get_by_return_type(self, tname: str) → Scope

Retrieve a Set of all signature by (return) type

get_by_symbol_name(self, name: str) → Scope

Retrieve a Set of all signature by symbol name

getsig_by_symbol_name(self, name: str) → Signature

Retrieve the unique Signature of a symbol. Fail if the Signature is not unique

intersection(self, sig: Scope) → Scope

Create a new Set produce by the intersection of 2 Set

intersection_update(self, oset: Scope) → Scope

Update Set with common values of another Set

keys(self)

Retrieve all keys

last(self) → Signature

Retrieve the last Signature ordered by mangling descendant

pop(self) → Signature

Pop a random Signature

remove(self, it: Signature) → bool

Remove it but raise KeyError if not found

set_name(self, name: str)

You could set the name after construction

set_parent(self, parent: Scope) → object

symmetric_difference(self, sig: Scope) → Scope

Create a new Set with values present in only one Set

symmetric_difference_update(self, oset: Scope) → Scope

Remove common values and Update specific values from another Set

union(self, sig: Scope) → Scope

Create a new Set produce by the union of 2 Set

update(self, sig: list) → Scope

Update the Set with values of another Set

values(self)

Retrieve all values

pyrser.type_system.StateScope

alias of Enum

class pyrser.type_system.Tuple(sig: [<class 'pyrser.type_system.signature.Signature'>]=None)

Bases: list

A tuple is just a list of signature.

__init__(self, sig= None)

__repr__(self) → str

Internal representation

__str__(self) → str

Usefull representation

add(self, sig: Signature)

to_fmt(self) → indentable

Return an Fmt representation for pretty-printing

class pyrser.type_system.Type(name: str, sig: [<class 'pyrser.type_system.signature.Signature'>]=None)

Bases: pyrser.type_system.scope.Scope

A Type is a named scope similar to ADT (Abstract Data Type). So we have member variables (ordered) that represent internal state. Member functions (work on an instance of type, depend of the language ref/or not). Non member variables/functions/values as in a scope.

__init__(self, name: str, sig= None)

__str__(self) → str

type_name

class pyrser.type_system.Var(name: str, tret: str)

Bases: pyrser.type_system.signature.Signature

Describe a variable signature for the language

__init__(self, name: str, tret: str)

__str__(self) → str

internal_name(self)

Return the unique internal name

is_polymorphic

class pyrser.type_system.Val(value, tret: str)

Bases: pyrser.type_system.signature.Signature

Describe a value signature for the language

__init__(self, value, tret: str)

__str__(self) → str

internal_name(self)

Return the unique internal name

nvalues = 0

valuniq = {}

class pyrser.type_system.Fun(name: str, tret: str, tparams: list=None, variadic=None)

Bases: pyrser.type_system.signature.Signature

Describe a function signature for the language

__init__(self, name: str, tret: str, tparams: list= None, variadic= None)

__str__(self) → str

arity

internal_name(self)

Return the unique internal name

is_polymorphic

return_type

this_type

class pyrser.type_system.Translator(fun: pyrser.type_system.fun.Fun, notify: pyrser.error.Notification=None)

Bases: object

Handle conversion from type_source to type_target thru a function. Do error.Notification if applyiable.

__hash__(self) → str

__init__(self, fun: Fun, notify: Notification= None)

__str__(self) → str

fun

notify

source

target

class pyrser.type_system.MapSourceTranslate

Bases: dict

Handle all conversions functions provide as Translator.

_MapSourceTranslate__reversed(self) → reversed

__contains__(self, key: str) → bool

__delitem__(self, key: str)

__getitem__(self, key: str) → MapTargetTranslate

__init__(self)

__iter__(self) → iter

__len__(self) → int

__setitem__(self, key: str, val: MapTargetTranslate)

__str__(self) → str

addTranslator(self, val: Translator, as_global= False)

set_parent(self, parent: MapSourceTranslate)

class pyrser.type_system.MapTargetTranslate

Bases: dict

Handle all translation to one type

_MapTargetTranslate__reversed(self) → reversed

__contains__(self, key: str) → bool

__delitem__(self, key: str)

__getitem__(self, key: str) → Translator

__init__(self)

__iter__(self) → iter

__len__(self) → int

__setitem__(self, key: str, val: Translator)

__str__(self) → str

key

class pyrser.type_system.Inference

Bases: object

feedback(self, diagnostic= None)

Do feedback. Write infos into diagnostic object, if this parameter is not provide and self is a AST (has is own diagnostic object), use the diagnostic of self.

feedback_block(self, diagnostic= None)

feedback_fun(self, diagnostic= None)

feedback_id(self, diagnostic= None)

feedback_leaf(self, diagnostic= None)

feedback_subexpr(self, diagnostic= None)

infer_block(self, body, diagnostic= None)

Infer type on block is to type each of is sub-element

infer_fun(self, args, diagnostic= None)

infer_id(self, ident, diagnostic= None)

Infer type from an ID! - check if ID is declarated in the scope - if no ID is polymorphic type

infer_literal(self, args, diagnostic= None)

Infer type from an LITERAL! Type of literal depend of language. We adopt a basic convention

infer_subexpr(self, expr, diagnostic= None)

Infer type on the subexpr

infer_type(self, init_scope: Scope= None, diagnostic= None)

Do inference. Write infos into diagnostic object, if this parameter is not provide and self is a AST (has is own diagnostic object), use the diagnostic of self.

type_algos(self)

Sub class must return a Tuple of 3 elements:

• the method to use to infer type.
• the list of params to used when infer a type.
• the method to use when feedback a type.

This is useful to connect AST members to generic algo or to overload some specific semantic for your language.

class pyrser.type_system.InferNode(init_scope: pyrser.type_system.scope.Scope=None, parent: pyrser.type_system.scope.Scope=None)

Bases: object

An instance of this class is automatically attach on each AST Nodes by the inference algorithm during the inference process into the ‘.infer_node’ attribute. The aim is to keep track of the correct Scope and the final EvalCtx for each AST Nodes.

__init__(self, init_scope: Scope= None, parent: Scope= None)