def create_enum_node_alternatives(mcs, enum_cls, enum_type): from langkit.expressions import Property enum_type.alternatives = enum_cls._alternatives enum_type.is_type_resolved = True enum_type._alternatives = [] for alt in enum_cls._alternatives: alt_name = enum_cls._name + alt.name # Generate the derived class corresponding to this alternative fields = [] if enum_cls._qualifier: prop = Property(alt.name.lower == 'present') prop.location = enum_cls._location fields.append(('as_bool', prop)) alt_type = ASTNodeType(name=alt_name, location=None, doc='', base=enum_type, fields=fields) alt._type = alt_type alt._enum_node_cls = enum_cls # Make the alternative derived class accessible from the root # node for the enum. enum_type._alternatives.append(alt_type)
def get_parse_fields(self, node: ct.ASTNodeType) -> List[ct.Field]: """ Return all the parse fields to be exposed as a field in record of node. :param node: The node type of which we want to get the parse fields. """ return node.get_parse_fields( lambda x: not x.is_overriding and not x.abstract and not x.null)
def __new__(mcs, name, bases, dct): # Does this subclass come from this module? If so, it's not to be # considered as a DSLType per se. is_base = ((len(bases) == 1 and bases[0] in (object, BaseStruct)) or dct.pop('_ASTNodeList__is_astnode_list_cls', False)) # Is this the root AST node type? is_root = not is_base and mcs.root_type is None if not is_base: mcs.process_subclass(name, bases, dct, is_root) cls = type.__new__(mcs, name, bases, dct) if is_root: mcs.root_type = cls if not is_base: mcs.astnode_types.append(cls) # Create the corresponding ASTNodeType subclass if cls._base is _ASTNodeList: # Only root list types are supposed to directly subclass # _ASTNodeList. element_type = cls._element_type._resolve() assert element_type astnode_type = element_type.list else: astnode_type = ASTNodeType( cls._name, cls._location, cls._doc, base=None if is_root else cls._base._resolve(), fields=cls._fields, env_spec=cls._env_spec, annotations=cls._annotations, is_token_node=cls._is_token_node, ) astnode_type.dsl_decl = cls cls._type = astnode_type return cls
def get_properties(self, node: ct.ASTNodeType) -> List[PropertyDef]: """ Return the list of all properties that should be exposed to the user. :param ct.ASTNodeType node: The node for which we want to get the properties. """ return [field for field in node.fields_with_accessors() if field.is_property]
def process_subclass(mcs, name, bases, dct, is_root): from langkit.envs import EnvSpec location = extract_library_location() base = bases[0] is_list_type = issubclass(base, _ASTNodeList) is_root_list_type = base is _ASTNodeList node_ctx = Context('in {}'.format(name), location) with node_ctx: check_source_language( len(bases) == 1, 'ASTNode subclasses must have exactly one' ' base class') if mcs.root_type is not None: check_source_language( base is not ASTNode, 'Only one class can derive from ASTNode (previous was:' ' {})'.format(mcs.root_type.__name__)) env_spec = dct.pop('env_spec', None) check_source_language( env_spec is None or isinstance(env_spec, EnvSpec), 'Invalid environment specification: {}'.format(env_spec)) annotations = dct.pop('annotations', None) # If this is a list type, determine the corresponding element type if is_list_type: element_type = (dct.pop('_element_type') if is_root_list_type else base._element_type) allowed_field_types = PropertyDef else: element_type = None allowed_field_types = AbstractNodeData # Determine if this is a token node with node_ctx: is_token_node = dct.pop('token_node', None) check_source_language( is_token_node is None or isinstance(is_token_node, bool), 'The "token_node" field, when present, must contain a boolean') # If "token_node" allocation is left to None, inherit it (default # is False). if is_token_node is None: is_token_node = bool(base._is_token_node) if is_token_node: allowed_field_types = (_UserField, PropertyDef) else: # Make sure that all derivations of a token node are token # nodes themselves. check_source_language( not base._is_token_node, '"token_node" annotation inconsistent with inherited AST' ' node') # Handle enum nodes with node_ctx: # Forbid inheriting from an enum node check_source_language( not base._is_enum_node, 'Inheriting from an enum node is forbidden.') # Determine if this is an enum node is_enum_node = dct.pop('enum_node', False) check_source_language( isinstance(is_enum_node, bool), 'The "enum_node" field, when present, must contain a boolean') if is_enum_node: qualifier = dct.pop('qualifier', False) if qualifier: alternatives = ['present', 'absent'] else: alternatives = dct.pop('alternatives', None) check_source_language(alternatives is not None, 'Missing "alternatives" field') check_source_language( isinstance(alternatives, list) and all(isinstance(alt, str) for alt in alternatives), 'The "alternatives" field must contain a list of ' 'strings') alts = [ _EnumNodeAlternative(names.Name.from_lower(alt)) for alt in alternatives ] allowed_field_types = (_UserField, PropertyDef) fields = ASTNode.collect_fields(name, location, dct, allowed_field_types) DSLType._import_base_type_info(name, location, dct) if is_enum_node: mcs.import_enum_node_attributes(dct, qualifier, alts, fields) dct['_fields'] = fields dct['_base'] = base dct['_env_spec'] = env_spec dct['_is_token_node'] = is_token_node dct['_is_enum_node'] = is_enum_node # Make sure subclasses don't inherit the "list_type" cache from their # base classes. dct['_list_type'] = None dct['_element_type'] = element_type dct['_annotations'] = annotations cls = type.__new__(mcs, name, bases, dct) mcs.astnode_types.append(cls) # Create the corresponding ASTNodeType subclass if cls._base is _ASTNodeList: # Only root list types are supposed to directly subclass # _ASTNodeList. element_type = cls._element_type._resolve() assert element_type astnode_type = element_type.list else: astnode_type = ASTNodeType( cls._name, cls._location, cls._doc, base=None if is_root else cls._base._resolve(), fields=cls._fields, env_spec=cls._env_spec, annotations=cls._annotations, # Only enum nodes are abstract at this point is_abstract=cls._is_enum_node, is_enum_node=cls._is_enum_node, is_bool_node=cls._is_enum_node and cls._qualifier, is_token_node=cls._is_token_node) astnode_type.dsl_decl = cls cls._type = astnode_type if is_enum_node: mcs.create_enum_node_alternatives(cls, astnode_type) return cls