def resolve(self, symbols: SymbolTable) -> FilesSourceDdv: container = symbols.lookup(self._symbol_name) assert isinstance(container, SymbolContainer) sdv = container.sdv assert isinstance( sdv, FilesSourceSdv), 'Referenced symbol must be FilesSourceSdv' return sdv.resolve(symbols)
def ret_val(symbols: SymbolTable) -> StringDdv: container = symbols.lookup(symbol_name) assert isinstance( container, SymbolContainer), 'Value in Symbol Table must be SymbolContainer' assert container.value_type == ValueType.STRING, 'Value type must be STRING' return container.sdv.resolve(symbols)
def resolve(self, symbols: SymbolTable) -> List[StringDdv]: container = symbols.lookup(self._symbol_reference.name) ddv = container.sdv.resolve(symbols) if isinstance(ddv, StringDdv): return [ddv] if isinstance(ddv, PathDdv): return [ddvs.string_ddv_of_single_path(ddv)] if isinstance(ddv, ListDdv): return list(ddv.string_elements) raise TypeError('Unknown Symbol Value: ' + str(ddv))
def resolve(self, symbols: SymbolTable) -> List[StringValue]: container = symbols.lookup(self._symbol_reference.name) value = container.resolver.resolve(symbols) if isinstance(value, StringValue): return [value] if isinstance(value, FileRef): return [csv.string_value_of_single_file_ref(value)] if isinstance(value, ListValue): return list(value.string_value_elements) raise TypeError('Unknown Symbol Value: ' + str(value))
def _validate_reference(symbol_reference: su.SymbolReference, symbols: SymbolTable) -> Optional[str]: referenced_resolver_container = symbols.lookup(symbol_reference.name) assert isinstance(referenced_resolver_container, SymbolContainer), \ 'Values in SymbolTable must be ResolverContainer' result = symbol_reference.restrictions.is_satisfied_by(symbols, symbol_reference.name, referenced_resolver_container) if result is None: return None return restriction_failures.error_message(symbol_reference.name, symbols, result)
def resolve(self, symbols: SymbolTable) -> StringSourceDdv: container = symbols.lookup(self._symbol_name) assert isinstance(container, SymbolContainer) # Type info for IDE sdv = container.sdv if isinstance(sdv, StringSourceSdv): return sdv.resolve(symbols) elif isinstance(sdv, StringSdv): return sdvs.ConstantStringStringSourceSdv(sdv).resolve(symbols) else: raise TypeError('Expected string-source or string, found: ' + str(container.value_type))
def resolve(self, symbols: SymbolTable) -> PathDdv: symbol_value_2_path = _WStrRenderingValueSymbol2PathResolverVisitor( self._suffix_sdv, self.default_relativity, symbols) container = symbols.lookup(self._path_or_string_symbol.name) assert isinstance( container, SymbolContainer), 'Implementation consistency/SymbolContainer' sdv = container.sdv assert isinstance( sdv, DataTypeSdv), 'Implementation consistency/DataTypeSdv' return symbol_value_2_path.visit(sdv)
def _assert_table_contains(put: unittest.TestCase, table: sut.SymbolTable, expected_symbol: NameAndValue): put.assertTrue(table.contains(expected_symbol.name), 'table SHOULD contain the value') put.assertIn(expected_symbol.name, table.names_set, 'names set should contain the value') put.assertIs(expected_symbol.value, table.lookup(expected_symbol.name), 'lookup should fins the value')
def _validate_reference(symbol_reference: SymbolReference, symbols: SymbolTable) -> Optional[TextRenderer]: referenced_sdv_container = symbols.lookup(symbol_reference.name) assert isinstance(referenced_sdv_container, SymbolContainer), \ 'Values in SymbolTable must be SymbolContainer' result = symbol_reference.restrictions.is_satisfied_by( symbols, symbol_reference.name, referenced_sdv_container) if result is None: return None return restriction_failures.ErrorMessage(symbol_reference.name, symbols, result)
def _assert_table_contains(put: unittest.TestCase, table: sut.SymbolTable, expected_symbol: NameAndValue[ASymbolTableValue]): put.assertTrue(table.contains(expected_symbol.name), 'table SHOULD contain the value') put.assertIn(expected_symbol.name, table.names_set, 'names set should contain the value') put.assertIs(expected_symbol.value, table.lookup(expected_symbol.name), 'lookup should fins the value')
def __assertions_on_reference_restrictions(self, put: unittest.TestCase, actual: PathSdv, symbols: SymbolTable): for idx, reference in enumerate(actual.references): assert isinstance(reference, SymbolReference) # Type info for IDE container = symbols.lookup(reference.name) assert isinstance(container, SymbolContainer) result = reference.restrictions.is_satisfied_by( symbols, reference.name, container) put.assertIsNone( result, 'Restriction on reference #{}: expects None=satisfaction'. format(idx))
def resolve(self, symbols: SymbolTable) -> sv.StringFragment: container = symbols.lookup(self._symbol_reference.name) assert isinstance(container, struct.SymbolContainer), 'Value in SymTbl must be SymbolContainer' value_resolver = container.resolver assert isinstance(value_resolver, DataValueResolver), 'Value must be a DataValueResolver' value = value_resolver.resolve(symbols) if isinstance(value, sv.StringValue): return csv.StringValueFragment(value) elif isinstance(value, FileRef): return csv.FileRefFragment(value) elif isinstance(value, ListValue): return csv.ListValueFragment(value) else: raise TypeError('Not a {}: {}'.format(str(DataValueResolver), value))
def resolve(self, symbols: SymbolTable) -> sv.StringFragmentDdv: container = symbols.lookup(self._symbol_reference.name) assert isinstance( container, SymbolContainer), 'Value in SymTbl must be SymbolContainer' value_sdv = container.sdv assert isinstance(value_sdv, DataTypeSdv), 'Value must be a DataTypeSdv' value = value_sdv.resolve(symbols) if isinstance(value, sv.StringDdv): return csv.StringDdvFragmentDdv(value) elif isinstance(value, PathDdv): return csv.PathFragmentDdv(value) elif isinstance(value, ListDdv): return csv.ListFragmentDdv(value) else: raise TypeError('Not a {}: {}'.format(str(DataTypeSdv), value))
def _validate_symbol_definition(symbol_table: SymbolTable, definition: su.SymbolDefinition, ) -> Optional[PartialInstructionControlledFailureInfo]: if symbol_table.contains(definition.name): already_defined_resolver_container = symbol_table.lookup(definition.name) assert isinstance(already_defined_resolver_container, SymbolContainer), \ 'Value in SymTbl must be ResolverContainer' return PartialInstructionControlledFailureInfo( PartialControlledFailureEnum.VALIDATION_ERROR, error_messages.duplicate_symbol_definition(already_defined_resolver_container.source_location, definition.name)) else: for referenced_value in definition.references: failure_info = validate_symbol_usage(referenced_value, symbol_table) if failure_info is not None: return failure_info symbol_table.add(definition.symbol_table_entry) return None
def _check_indirect(self, symbol_table: SymbolTable, path_to_referring_symbol: tuple, references: list) -> FailureOfIndirectReference: for reference in references: container = symbol_table.lookup(reference.name) result = self._indirect.is_satisfied_by(symbol_table, reference.name, container) if result is not None: return FailureOfIndirectReference( failing_symbol=reference.name, path_to_failing_symbol=list(path_to_referring_symbol), error=result, meaning_of_failure=self._meaning_of_failure_of_indirect_reference) result = self._check_indirect(symbol_table, path_to_referring_symbol + (reference.name,), container.resolver.references) if result is not None: return result return None
def _validate_symbol_definition( symbol_table: SymbolTable, definition: SymbolDefinition, ) -> Optional[PartialInstructionControlledFailureInfo]: if symbol_table.contains(definition.name): already_defined_sdv_container = symbol_table.lookup(definition.name) assert isinstance(already_defined_sdv_container, SymbolContainer), \ 'Value in SymTbl must be ResolverContainer' return PartialInstructionControlledFailureInfo( PartialControlledFailureEnum.VALIDATION_ERROR, error_messages.duplicate_symbol_definition( already_defined_sdv_container.source_location, definition.name)) else: for referenced_value in definition.references: failure_info = validate_symbol_usage(referenced_value, symbol_table) if failure_info is not None: return failure_info symbol_table.add(definition.symbol_table_entry) return None
def _check_indirect( self, symbol_table: SymbolTable, path_to_referring_symbol: tuple, references: Sequence[SymbolReference] ) -> Optional[FailureOfIndirectReference]: for reference in references: container = symbol_table.lookup(reference.name) assert isinstance(container, SymbolContainer) # Type info for IDE result = self._indirect.is_satisfied_by(symbol_table, reference.name, container) if result is not None: return FailureOfIndirectReference( failing_symbol=reference.name, path_to_failing_symbol=list(path_to_referring_symbol), error=result, meaning_of_failure=self. _meaning_of_failure_of_indirect_reference) result = self._check_indirect( symbol_table, path_to_referring_symbol + (reference.name, ), container.sdv.references) if result is not None: return result return None
def lookup_container(symbols: SymbolTable, name: str) -> SymbolContainer: container = symbols.lookup(name) assert isinstance( container, SymbolContainer), 'Value in SymTbl must be SymbolContainer' return container
def ret_val(symbols: SymbolTable) -> StringValue: container = symbols.lookup(symbol_name) assert isinstance(container, SymbolContainer), 'Value in SymTbl must be SymbolContainer' return container.resolver.resolve(symbols)
def lookup_container(symbols: SymbolTable, name: str) -> SymbolContainer: container = symbols.lookup(name) assert isinstance(container, SymbolContainer), 'Value in SymTbl must be SymbolContainer' return container