From 955160b6c6c6d3dbff54bd203290e723dadabe9f Mon Sep 17 00:00:00 2001 From: Marko Ristin-Kaufmann Date: Sat, 3 Oct 2026 21:30:14 +0200 Subject: [PATCH] Fix signatures of methods with two arguments The C#, Java and TypeScript interfaces rendered the public methods with more than two arguments on multiple lines, with exactly one on a single line, and otherwise asserted that there were no arguments. Hence a method with exactly two arguments failed the assertion. We now split ``if len(arg_codes) > 1:``. The Go enhancing joined the arguments with ``,`` although each already ended with one, rendering ``low int64,,high int64,``. We now join them with new lines. We test it with ``Item.is_count_between(self, low, high)`` in the ``transpiled_methods`` meta-model. --- .../csharp/lib/_generate_types.py | 2 +- .../golang/lib/_generate_enhancing.py | 2 +- aas_core_codegen/java/lib/_generate_types.py | 2 +- .../typescript/lib/_generate_types.py | 2 +- .../common_meta_models/transpiled_methods.py | 5 + .../expected_symbol_table.txt | 238 ++++++++++++++++++ .../include/dummy/enhancing.hpp | 20 ++ .../expected_output/include/dummy/types.hpp | 16 ++ .../expected_output/src/types.cpp | 24 ++ .../expected_output/dummy/enhancing.cs | 22 ++ .../expected_output/dummy/types.cs | 31 +++ .../expected_output/enhancing/enhancing.go | 20 ++ .../expected_output/types/types.go | 36 +++ .../java/dummy/enhancing/EnhancedFirst.java | 11 + .../java/dummy/enhancing/EnhancedSecond.java | 11 + .../src/main/java/dummy/types/impl/First.java | 12 + .../main/java/dummy/types/impl/Second.java | 12 + .../main/java/dummy/types/model/IItem.java | 7 + .../expected_output/dummy/types.py | 15 ++ .../expected_output/src/types.ts | 34 +++ .../expected_symbol_table.txt | 68 +++++ 21 files changed, 586 insertions(+), 4 deletions(-) diff --git a/aas_core_codegen/csharp/lib/_generate_types.py b/aas_core_codegen/csharp/lib/_generate_types.py index a8cbe5b33..8f1acd6ff 100644 --- a/aas_core_codegen/csharp/lib/_generate_types.py +++ b/aas_core_codegen/csharp/lib/_generate_types.py @@ -627,7 +627,7 @@ def _generate_interface( arg_codes.append(Stripped(f"{arg_type} {arg_name}")) signature_name = csharp_naming.method_name(method.name) - if len(arg_codes) > 2: + if len(arg_codes) > 1: arg_block = ",\n".join(arg_codes) arg_block_indented = textwrap.indent(arg_block, I) signature_blocks.append( diff --git a/aas_core_codegen/golang/lib/_generate_enhancing.py b/aas_core_codegen/golang/lib/_generate_enhancing.py index e9d99eb09..cead63776 100644 --- a/aas_core_codegen/golang/lib/_generate_enhancing.py +++ b/aas_core_codegen/golang/lib/_generate_enhancing.py @@ -66,7 +66,7 @@ def _generate_method_delegation( }}""" ) - arguments_definition = ",".join( + arguments_definition = "\n".join( f"{arg_name} {arg_type}," for arg_type, arg_name in arg_types_names ) diff --git a/aas_core_codegen/java/lib/_generate_types.py b/aas_core_codegen/java/lib/_generate_types.py index a9eb05081..3bd2b3770 100644 --- a/aas_core_codegen/java/lib/_generate_types.py +++ b/aas_core_codegen/java/lib/_generate_types.py @@ -989,7 +989,7 @@ def _generate_interface( arg_codes.append(Stripped(f"{arg_type} {arg_name}")) signature_name = java_naming.method_name(method.name) - if len(arg_codes) > 2: + if len(arg_codes) > 1: arg_block = ",\n".join(arg_codes) arg_block_indented = textwrap.indent(arg_block, I) signature_blocks.append( diff --git a/aas_core_codegen/typescript/lib/_generate_types.py b/aas_core_codegen/typescript/lib/_generate_types.py index b6c9e918c..da2000c94 100644 --- a/aas_core_codegen/typescript/lib/_generate_types.py +++ b/aas_core_codegen/typescript/lib/_generate_types.py @@ -1157,7 +1157,7 @@ def _generate_interface( arg_codes.append(Stripped(f"{arg_name}: {arg_type}")) signature_name = typescript_naming.method_name(signature.name) - if len(arg_codes) > 2: + if len(arg_codes) > 1: arg_block = ",\n".join(arg_codes) signature_blocks.append( Stripped( diff --git a/dev/test_data/common_meta_models/transpiled_methods.py b/dev/test_data/common_meta_models/transpiled_methods.py index 40cdc5d52..1208797ca 100644 --- a/dev/test_data/common_meta_models/transpiled_methods.py +++ b/dev/test_data/common_meta_models/transpiled_methods.py @@ -59,6 +59,11 @@ def is_count_within(self, limit: int) -> bool: """Check that the count does not exceed :paramref:`limit`.""" return self.count <= limit + @non_mutating + def is_count_between(self, low: int, high: int) -> bool: + """Check that the count is between :paramref:`low` and :paramref:`high`.""" + return low <= self.count and self.count <= high + @non_mutating def is_empty(self) -> bool: """Check that there are no texts, calling another method on ``self``.""" diff --git a/dev/test_data/intermediate/common_meta_models/transpiled_methods/expected_symbol_table.txt b/dev/test_data/intermediate/common_meta_models/transpiled_methods/expected_symbol_table.txt index 6501cd2cb..54b929deb 100644 --- a/dev/test_data/intermediate/common_meta_models/transpiled_methods/expected_symbol_table.txt +++ b/dev/test_data/intermediate/common_meta_models/transpiled_methods/expected_symbol_table.txt @@ -138,6 +138,40 @@ SymbolTable( postconditions=[]), parsed=..., arguments_by_name=...), + Signature( + name='is_count_between', + arguments=[ + Argument( + name='low', + type_annotation=PrimitiveTypeAnnotation( + a_type='INT', + parsed=...), + default=None, + mutable=False, + parsed=...), + Argument( + name='high', + type_annotation=PrimitiveTypeAnnotation( + a_type='INT', + parsed=...), + default=None, + mutable=False, + parsed=...)], + returns=PrimitiveTypeAnnotation( + a_type='BOOL', + parsed=...), + description=DescriptionOfSignature( + summary='Check that the count is between low and high.', + remarks=[], + arguments_by_name=[], + returns=None, + parsed=...), + contracts=Contracts( + preconditions=[], + snapshots=[], + postconditions=[]), + parsed=..., + arguments_by_name=...), Signature( name='is_empty', arguments=[], @@ -501,6 +535,74 @@ SymbolTable( original_node=...), original_node=...)""")], arguments_by_name=...), + UnderstoodMethod( + name='is_count_between', + visibility='PUBLIC', + arguments=[ + Argument( + name='low', + type_annotation=PrimitiveTypeAnnotation( + a_type='INT', + parsed=...), + default=None, + mutable=False, + parsed=...), + Argument( + name='high', + type_annotation=PrimitiveTypeAnnotation( + a_type='INT', + parsed=...), + default=None, + mutable=False, + parsed=...)], + returns=PrimitiveTypeAnnotation( + a_type='BOOL', + parsed=...), + description=DescriptionOfSignature( + summary='Check that the count is between low and high.', + remarks=[], + arguments_by_name=[], + returns=None, + parsed=...), + specified_for='Reference to AbstractClass Item', + contracts=Contracts( + preconditions=[], + snapshots=[], + postconditions=[]), + non_mutating=True, + parsed=..., + body=[ + textwrap.dedent("""\ + Return( + value=And( + values=[ + Comparison( + left=Name( + identifier='low', + original_node=...), + op='LE', + right=Member( + instance=Name( + identifier='self', + original_node=...), + name='count', + original_node=...), + original_node=...), + Comparison( + left=Member( + instance=Name( + identifier='self', + original_node=...), + name='count', + original_node=...), + op='LE', + right=Name( + identifier='high', + original_node=...), + original_node=...)], + original_node=...), + original_node=...)""")], + arguments_by_name=...), UnderstoodMethod( name='is_empty', visibility='PUBLIC', @@ -1321,6 +1423,74 @@ SymbolTable( original_node=...), original_node=...)""")], arguments_by_name=...), + UnderstoodMethod( + name='is_count_between', + visibility='PUBLIC', + arguments=[ + Argument( + name='low', + type_annotation=PrimitiveTypeAnnotation( + a_type='INT', + parsed=...), + default=None, + mutable=False, + parsed=...), + Argument( + name='high', + type_annotation=PrimitiveTypeAnnotation( + a_type='INT', + parsed=...), + default=None, + mutable=False, + parsed=...)], + returns=PrimitiveTypeAnnotation( + a_type='BOOL', + parsed=...), + description=DescriptionOfSignature( + summary='Check that the count is between low and high.', + remarks=[], + arguments_by_name=[], + returns=None, + parsed=...), + specified_for='Reference to AbstractClass Item', + contracts=Contracts( + preconditions=[], + snapshots=[], + postconditions=[]), + non_mutating=True, + parsed=..., + body=[ + textwrap.dedent("""\ + Return( + value=And( + values=[ + Comparison( + left=Name( + identifier='low', + original_node=...), + op='LE', + right=Member( + instance=Name( + identifier='self', + original_node=...), + name='count', + original_node=...), + original_node=...), + Comparison( + left=Member( + instance=Name( + identifier='self', + original_node=...), + name='count', + original_node=...), + op='LE', + right=Name( + identifier='high', + original_node=...), + original_node=...)], + original_node=...), + original_node=...)""")], + arguments_by_name=...), UnderstoodMethod( name='is_empty', visibility='PUBLIC', @@ -2139,6 +2309,74 @@ SymbolTable( original_node=...), original_node=...)""")], arguments_by_name=...), + UnderstoodMethod( + name='is_count_between', + visibility='PUBLIC', + arguments=[ + Argument( + name='low', + type_annotation=PrimitiveTypeAnnotation( + a_type='INT', + parsed=...), + default=None, + mutable=False, + parsed=...), + Argument( + name='high', + type_annotation=PrimitiveTypeAnnotation( + a_type='INT', + parsed=...), + default=None, + mutable=False, + parsed=...)], + returns=PrimitiveTypeAnnotation( + a_type='BOOL', + parsed=...), + description=DescriptionOfSignature( + summary='Check that the count is between low and high.', + remarks=[], + arguments_by_name=[], + returns=None, + parsed=...), + specified_for='Reference to AbstractClass Item', + contracts=Contracts( + preconditions=[], + snapshots=[], + postconditions=[]), + non_mutating=True, + parsed=..., + body=[ + textwrap.dedent("""\ + Return( + value=And( + values=[ + Comparison( + left=Name( + identifier='low', + original_node=...), + op='LE', + right=Member( + instance=Name( + identifier='self', + original_node=...), + name='count', + original_node=...), + original_node=...), + Comparison( + left=Member( + instance=Name( + identifier='self', + original_node=...), + name='count', + original_node=...), + op='LE', + right=Name( + identifier='high', + original_node=...), + original_node=...)], + original_node=...), + original_node=...)""")], + arguments_by_name=...), UnderstoodMethod( name='is_empty', visibility='PUBLIC', diff --git a/dev/test_data/main/cpp/expected/transpiled_methods/expected_output/include/dummy/enhancing.hpp b/dev/test_data/main/cpp/expected/transpiled_methods/expected_output/include/dummy/enhancing.hpp index 0cd88e186..f6c3b119d 100644 --- a/dev/test_data/main/cpp/expected/transpiled_methods/expected_output/include/dummy/enhancing.hpp +++ b/dev/test_data/main/cpp/expected/transpiled_methods/expected_output/include/dummy/enhancing.hpp @@ -155,6 +155,16 @@ class EnhancedFirst ); } + bool IsCountBetween( + int64_t low, + int64_t high + ) const override { + return instance_->IsCountBetween( + low, + high + ); + } + bool IsEmpty() const override { return instance_->IsEmpty(); } @@ -310,6 +320,16 @@ class EnhancedSecond ); } + bool IsCountBetween( + int64_t low, + int64_t high + ) const override { + return instance_->IsCountBetween( + low, + high + ); + } + bool IsEmpty() const override { return instance_->IsEmpty(); } diff --git a/dev/test_data/main/cpp/expected/transpiled_methods/expected_output/include/dummy/types.hpp b/dev/test_data/main/cpp/expected/transpiled_methods/expected_output/include/dummy/types.hpp index b5d88af55..6223e80d6 100644 --- a/dev/test_data/main/cpp/expected/transpiled_methods/expected_output/include/dummy/types.hpp +++ b/dev/test_data/main/cpp/expected/transpiled_methods/expected_output/include/dummy/types.hpp @@ -105,6 +105,12 @@ class IItem int64_t limit ) const = 0; + /// \brief Check that the count is between \p low and \p high. + virtual bool IsCountBetween( + int64_t low, + int64_t high + ) const = 0; + /// \brief Check that there are no texts, calling another method on `self`. virtual bool IsEmpty() const = 0; @@ -231,6 +237,11 @@ class First int64_t limit ) const override; + bool IsCountBetween( + int64_t low, + int64_t high + ) const override; + bool IsEmpty() const override; int64_t Parity() const override; @@ -334,6 +345,11 @@ class Second int64_t limit ) const override; + bool IsCountBetween( + int64_t low, + int64_t high + ) const override; + bool IsEmpty() const override; int64_t Parity() const override; diff --git a/dev/test_data/main/cpp/expected/transpiled_methods/expected_output/src/types.cpp b/dev/test_data/main/cpp/expected/transpiled_methods/expected_output/src/types.cpp index d7fba52c9..dcf144b7b 100644 --- a/dev/test_data/main/cpp/expected/transpiled_methods/expected_output/src/types.cpp +++ b/dev/test_data/main/cpp/expected/transpiled_methods/expected_output/src/types.cpp @@ -96,6 +96,18 @@ bool First::IsCountWithin( return this->count() <= limit; } +bool First::IsCountBetween( + int64_t low, + int64_t high +) const { + return ( + ( + low <= this->count() + && this->count() <= high + ) + ); +} + bool First::IsEmpty() const { return ( ( @@ -256,6 +268,18 @@ bool Second::IsCountWithin( return this->count() <= limit; } +bool Second::IsCountBetween( + int64_t low, + int64_t high +) const { + return ( + ( + low <= this->count() + && this->count() <= high + ) + ); +} + bool Second::IsEmpty() const { return ( ( diff --git a/dev/test_data/main/csharp/expected/transpiled_methods/expected_output/dummy/enhancing.cs b/dev/test_data/main/csharp/expected/transpiled_methods/expected_output/dummy/enhancing.cs index 77cc95094..d631359cd 100644 --- a/dev/test_data/main/csharp/expected/transpiled_methods/expected_output/dummy/enhancing.cs +++ b/dev/test_data/main/csharp/expected/transpiled_methods/expected_output/dummy/enhancing.cs @@ -84,6 +84,17 @@ long limit ); } + public bool IsCountBetween( + long low, + long high + ) + { + return _instance.IsCountBetween( + low, + high + ); + } + public bool IsEmpty() { return _instance.IsEmpty(); @@ -229,6 +240,17 @@ long limit ); } + public bool IsCountBetween( + long low, + long high + ) + { + return _instance.IsCountBetween( + low, + high + ); + } + public bool IsEmpty() { return _instance.IsEmpty(); diff --git a/dev/test_data/main/csharp/expected/transpiled_methods/expected_output/dummy/types.cs b/dev/test_data/main/csharp/expected/transpiled_methods/expected_output/dummy/types.cs index ec9d8db92..a8143876c 100644 --- a/dev/test_data/main/csharp/expected/transpiled_methods/expected_output/dummy/types.cs +++ b/dev/test_data/main/csharp/expected/transpiled_methods/expected_output/dummy/types.cs @@ -88,6 +88,13 @@ public interface IItem : IClass /// public bool IsCountWithin(long limit); + /// + /// Check that the count is between and . + /// + public bool IsCountBetween( + long low, + long high); + /// /// Check that there are no texts, calling another method on self. /// @@ -186,6 +193,18 @@ long limit return this.Count <= limit; } + /// + /// Check that the count is between and . + /// + public bool IsCountBetween( + long low, + long high + ) + { + return low <= this.Count + && this.Count <= high; + } + /// /// Check that there are no texts, calling another method on self. /// @@ -405,6 +424,18 @@ long limit return this.Count <= limit; } + /// + /// Check that the count is between and . + /// + public bool IsCountBetween( + long low, + long high + ) + { + return low <= this.Count + && this.Count <= high; + } + /// /// Check that there are no texts, calling another method on self. /// diff --git a/dev/test_data/main/golang/expected/transpiled_methods/expected_output/enhancing/enhancing.go b/dev/test_data/main/golang/expected/transpiled_methods/expected_output/enhancing/enhancing.go index d7223c6ff..dbe9ba9e1 100644 --- a/dev/test_data/main/golang/expected/transpiled_methods/expected_output/enhancing/enhancing.go +++ b/dev/test_data/main/golang/expected/transpiled_methods/expected_output/enhancing/enhancing.go @@ -92,6 +92,16 @@ func (f *enhancedFirst[E]) IsCountWithin( ) } +func (f *enhancedFirst[E]) IsCountBetween( + low int64, + high int64, +) bool { + return f.instance.IsCountBetween( + low, + high, + ) +} + func (f *enhancedFirst[E]) IsEmpty() bool { return f.instance.IsEmpty() } @@ -249,6 +259,16 @@ func (s *enhancedSecond[E]) IsCountWithin( ) } +func (s *enhancedSecond[E]) IsCountBetween( + low int64, + high int64, +) bool { + return s.instance.IsCountBetween( + low, + high, + ) +} + func (s *enhancedSecond[E]) IsEmpty() bool { return s.instance.IsEmpty() } diff --git a/dev/test_data/main/golang/expected/transpiled_methods/expected_output/types/types.go b/dev/test_data/main/golang/expected/transpiled_methods/expected_output/types/types.go index 330d19732..510eaa801 100644 --- a/dev/test_data/main/golang/expected/transpiled_methods/expected_output/types/types.go +++ b/dev/test_data/main/golang/expected/transpiled_methods/expected_output/types/types.go @@ -101,6 +101,12 @@ type IItem interface { limit int64, ) bool; + // Check that the count is between low and high. + IsCountBetween( + low int64, + high int64, + ) bool; + // Check that there are no texts, calling another method on `self`. IsEmpty() bool; @@ -174,6 +180,12 @@ type IFirst interface { limit int64, ) bool; + // Check that the count is between low and high. + IsCountBetween( + low int64, + high int64, + ) bool; + // Check that there are no texts, calling another method on `self`. IsEmpty() bool; @@ -299,6 +311,15 @@ func (f *First) IsCountWithin( return f.Count() <= limit } +// Check that the count is between low and high. +func (f *First) IsCountBetween( + low int64, + high int64, +) bool { + return low <= f.Count() && + f.Count() <= high +} + // Check that there are no texts, calling another method on `self`. func (f *First) IsEmpty() bool { return len(f.Texts()) == 0 && @@ -443,6 +464,12 @@ type ISecond interface { limit int64, ) bool; + // Check that the count is between low and high. + IsCountBetween( + low int64, + high int64, + ) bool; + // Check that there are no texts, calling another method on `self`. IsEmpty() bool; @@ -583,6 +610,15 @@ func (s *Second) IsCountWithin( return s.Count() <= limit } +// Check that the count is between low and high. +func (s *Second) IsCountBetween( + low int64, + high int64, +) bool { + return low <= s.Count() && + s.Count() <= high +} + // Check that there are no texts, calling another method on `self`. func (s *Second) IsEmpty() bool { return len(s.Texts()) == 0 && diff --git a/dev/test_data/main/java/expected/transpiled_methods/expected_output/src/main/java/dummy/enhancing/EnhancedFirst.java b/dev/test_data/main/java/expected/transpiled_methods/expected_output/src/main/java/dummy/enhancing/EnhancedFirst.java index d9c8672bd..8bb01ac0d 100644 --- a/dev/test_data/main/java/expected/transpiled_methods/expected_output/src/main/java/dummy/enhancing/EnhancedFirst.java +++ b/dev/test_data/main/java/expected/transpiled_methods/expected_output/src/main/java/dummy/enhancing/EnhancedFirst.java @@ -82,6 +82,17 @@ public Boolean isCountWithin( ); } + public Boolean isCountBetween( + Long low, + Long high + ) + { + return instance.isCountBetween( + low, + high + ); + } + public Boolean isEmpty() { return instance.isEmpty(); } diff --git a/dev/test_data/main/java/expected/transpiled_methods/expected_output/src/main/java/dummy/enhancing/EnhancedSecond.java b/dev/test_data/main/java/expected/transpiled_methods/expected_output/src/main/java/dummy/enhancing/EnhancedSecond.java index c16ebc1cf..1def89e1e 100644 --- a/dev/test_data/main/java/expected/transpiled_methods/expected_output/src/main/java/dummy/enhancing/EnhancedSecond.java +++ b/dev/test_data/main/java/expected/transpiled_methods/expected_output/src/main/java/dummy/enhancing/EnhancedSecond.java @@ -92,6 +92,17 @@ public Boolean isCountWithin( ); } + public Boolean isCountBetween( + Long low, + Long high + ) + { + return instance.isCountBetween( + low, + high + ); + } + public Boolean isEmpty() { return instance.isEmpty(); } diff --git a/dev/test_data/main/java/expected/transpiled_methods/expected_output/src/main/java/dummy/types/impl/First.java b/dev/test_data/main/java/expected/transpiled_methods/expected_output/src/main/java/dummy/types/impl/First.java index a55404809..cc9755923 100644 --- a/dev/test_data/main/java/expected/transpiled_methods/expected_output/src/main/java/dummy/types/impl/First.java +++ b/dev/test_data/main/java/expected/transpiled_methods/expected_output/src/main/java/dummy/types/impl/First.java @@ -117,6 +117,18 @@ public Boolean isCountWithin( return this.getCount() <= limit; } + /** + * Check that the count is between {@code low} and {@code high}. + */ + @Override + public Boolean isCountBetween( + Long low, + Long high + ) { + return low <= this.getCount() + && this.getCount() <= high; + } + /** * Check that there are no texts, calling another method on {@code self}. */ diff --git a/dev/test_data/main/java/expected/transpiled_methods/expected_output/src/main/java/dummy/types/impl/Second.java b/dev/test_data/main/java/expected/transpiled_methods/expected_output/src/main/java/dummy/types/impl/Second.java index 0da0eb9ac..b48e1aa5d 100644 --- a/dev/test_data/main/java/expected/transpiled_methods/expected_output/src/main/java/dummy/types/impl/Second.java +++ b/dev/test_data/main/java/expected/transpiled_methods/expected_output/src/main/java/dummy/types/impl/Second.java @@ -142,6 +142,18 @@ public Boolean isCountWithin( return this.getCount() <= limit; } + /** + * Check that the count is between {@code low} and {@code high}. + */ + @Override + public Boolean isCountBetween( + Long low, + Long high + ) { + return low <= this.getCount() + && this.getCount() <= high; + } + /** * Check that there are no texts, calling another method on {@code self}. */ diff --git a/dev/test_data/main/java/expected/transpiled_methods/expected_output/src/main/java/dummy/types/model/IItem.java b/dev/test_data/main/java/expected/transpiled_methods/expected_output/src/main/java/dummy/types/model/IItem.java index 7efa8d546..174079cf9 100644 --- a/dev/test_data/main/java/expected/transpiled_methods/expected_output/src/main/java/dummy/types/model/IItem.java +++ b/dev/test_data/main/java/expected/transpiled_methods/expected_output/src/main/java/dummy/types/model/IItem.java @@ -41,6 +41,13 @@ public interface IItem extends IClass { */ Boolean isCountWithin(Long limit); + /** + * Check that the count is between {@code low} and {@code high}. + */ + Boolean isCountBetween( + Long low, + Long high); + /** * Check that there are no texts, calling another method on {@code self}. */ diff --git a/dev/test_data/main/python/expected/transpiled_methods/expected_output/dummy/types.py b/dev/test_data/main/python/expected/transpiled_methods/expected_output/dummy/types.py index c5f0a0025..df2d60139 100644 --- a/dev/test_data/main/python/expected/transpiled_methods/expected_output/dummy/types.py +++ b/dev/test_data/main/python/expected/transpiled_methods/expected_output/dummy/types.py @@ -140,6 +140,21 @@ def is_count_within( # pylint: disable=all return self.count <= limit + def is_count_between( + self, + low: int, + high: int + ) -> bool: + """ + Check that the count is between :paramref:`low` and :paramref:`high`. + """ + # pylint: disable=all + return ( + ( + low <= self.count + and self.count <= high + )) + def is_empty(self) -> bool: """ Check that there are no texts, calling another method on ``self``. diff --git a/dev/test_data/main/typescript/expected/transpiled_methods/expected_output/src/types.ts b/dev/test_data/main/typescript/expected/transpiled_methods/expected_output/src/types.ts index ad1e39116..9f06353e6 100644 --- a/dev/test_data/main/typescript/expected/transpiled_methods/expected_output/src/types.ts +++ b/dev/test_data/main/typescript/expected/transpiled_methods/expected_output/src/types.ts @@ -143,6 +143,14 @@ export interface IItem extends Class { */ isCountWithin(limit: number): boolean; + /** + * Check that the count is between `low` and `high`. + */ + isCountBetween( + low: number, + high: number + ): boolean; + /** * Check that there are no texts, calling another method on `self`. */ @@ -251,6 +259,19 @@ export class First return this.count <= limit; } + /** + * Check that the count is between `low` and `high`. + */ + isCountBetween( + low: number, + high: number + ): boolean { + return ( + low <= this.count + && this.count <= high + ); + } + /** * Check that there are no texts, calling another method on `self`. */ @@ -481,6 +502,19 @@ export class Second return this.count <= limit; } + /** + * Check that the count is between `low` and `high`. + */ + isCountBetween( + low: number, + high: number + ): boolean { + return ( + low <= this.count + && this.count <= high + ); + } + /** * Check that there are no texts, calling another method on `self`. */ diff --git a/dev/test_data/parse/common_meta_models/transpiled_methods/expected_symbol_table.txt b/dev/test_data/parse/common_meta_models/transpiled_methods/expected_symbol_table.txt index 2d1858428..9826bd220 100644 --- a/dev/test_data/parse/common_meta_models/transpiled_methods/expected_symbol_table.txt +++ b/dev/test_data/parse/common_meta_models/transpiled_methods/expected_symbol_table.txt @@ -231,6 +231,74 @@ UnverifiedSymbolTable( original_node=...)""")], node=..., arguments_by_name=...), + UnderstoodMethod( + name='is_count_between', + verification=False, + visibility='PUBLIC', + arguments=[ + Argument( + name='self', + type_annotation=SelfTypeAnnotation(), + default=None, + node=...), + Argument( + name='low', + type_annotation=AtomicTypeAnnotation( + identifier='int', + node=...), + default=None, + node=...), + Argument( + name='high', + type_annotation=AtomicTypeAnnotation( + identifier='int', + node=...), + default=None, + node=...)], + returns=AtomicTypeAnnotation( + identifier='bool', + node=...), + description=Description( + document=..., + node=...), + contracts=Contracts( + preconditions=[], + snapshots=[], + postconditions=[]), + non_mutating=True, + body=[ + textwrap.dedent("""\ + Return( + value=And( + values=[ + Comparison( + left=Name( + identifier='low', + original_node=...), + op='LE', + right=Member( + instance=Name( + identifier='self', + original_node=...), + name='count', + original_node=...), + original_node=...), + Comparison( + left=Member( + instance=Name( + identifier='self', + original_node=...), + name='count', + original_node=...), + op='LE', + right=Name( + identifier='high', + original_node=...), + original_node=...)], + original_node=...), + original_node=...)""")], + node=..., + arguments_by_name=...), UnderstoodMethod( name='is_empty', verification=False,