[PerlCritic] add explicit return

fperrad · fperrad · commit f41047ac59cd · 2025-05-07T20:06:33.000+02:00
see https://metacpan.org/pod/Perl::Critic::Policy::Subroutines::RequireFinalReturn
diff --git a/perl/bin/gherkin-generate-tokens b/perl/bin/gherkin-generate-tokens
@@ -18,6 +18,7 @@ sub run {
     print $fh join "\n", @{ $parser->parse($_) } for @file_list;
     print $fh "\n";
 
+    return;
 }
 
 __PACKAGE__->run(\*STDOUT, @ARGV) unless caller;
diff --git a/perl/gherkin-perl.razor b/perl/gherkin-perl.razor
@@ -83,7 +83,7 @@ sub match_token {
     my ( $self, $state, $token, $context ) = @@_;
     my $method_name = $states_to_match_names{ $state } ||
         die "Unknown state: $state";
-    $self->$method_name( $token, $context );
+    return $self->$method_name( $token, $context );
 }
 
 sub _construct_parser_error {
diff --git a/perl/lib/Gherkin.pm b/perl/lib/Gherkin.pm
@@ -59,6 +59,7 @@ sub from_paths {
             $id_generator,
             $sink);
     }
+    return;
 }
 
 sub _parse_source_encoding_header {
@@ -82,6 +83,7 @@ sub _parse_source_encoding_header {
             unless $enc;
         $source->data( $enc->decode(encode_utf8($source->data)) );
     }
+    return;
 }
 
 sub _parser_error_message {
@@ -121,7 +123,7 @@ sub from_source {
             $sink->($ast_msg) if $self->include_ast;
 
             if ($self->include_pickles) {
-                Gherkin::Pickles::Compiler->compile(
+                return Gherkin::Pickles::Compiler->compile(
                     $ast_msg,
                     $id_generator,
                     $sink);
@@ -142,6 +144,7 @@ sub from_source {
             die $@; # rethrow
         }
     }
+    return;
 }
 
 
diff --git a/perl/lib/Gherkin/AstBuilder.pm b/perl/lib/Gherkin/AstBuilder.pm
@@ -27,14 +27,15 @@ sub new {
 }
 
 # Simple builder sugar
-sub ast_node { Gherkin::AstNode->new( $_[0] ) }
+sub ast_node { return Gherkin::AstNode->new( $_[0] ); }
 
 sub reset {
     my $self  = shift;
     my ($uri) = @_;
     $self->{'stack'}    = [ ast_node('None') ];
     $self->{'comments'} = [];
     $self->{'uri'}      = $uri;
+    return;
 }
 
 sub current_node {
@@ -45,12 +46,14 @@ sub current_node {
 sub start_rule {
     my ( $self, $rule_type ) = @_;
     push( @{ $self->{'stack'} }, ast_node($rule_type) );
+    return;
 }
 
 sub end_rule {
     my ( $self, $rule_type ) = @_;
     my $node = pop( @{ $self->{'stack'} } );
     $self->current_node->add( $node->rule_type, $self->transform_node($node) );
+    return;
 }
 
 sub build {
@@ -64,6 +67,7 @@ sub build {
     } else {
         $self->current_node->add( $token->matched_type, $token );
     }
+    return;
 }
 
 sub get_result {
@@ -134,6 +138,7 @@ sub ensure_cell_count {
                 $row->location );
         }
     }
+    return;
 }
 
 sub get_cells {
diff --git a/perl/lib/Gherkin/AstNode.pm b/perl/lib/Gherkin/AstNode.pm
@@ -7,12 +7,13 @@ use Class::XSAccessor accessors => [ qw/rule_type/, ];
 
 sub new {
     my ( $class, $rule_type ) = @_;
-    bless { rule_type => $rule_type, _sub_items => {} }, $class;
+    return bless { rule_type => $rule_type, _sub_items => {} }, $class;
 }
 
 sub add {
     my ( $self, $rule_type, $obj ) = @_;
     push( @{ ( $self->{'_sub_items'}->{$rule_type} ||= [] ) }, $obj );
+    return;
 }
 
 sub get_single {
diff --git a/perl/lib/Gherkin/Dialect.pm b/perl/lib/Gherkin/Dialect.pm
@@ -41,26 +41,27 @@ sub change_dialect {
       unless $self->dictionary->{$name};
     $self->{'dialect'} = $name;
     $self->{'_current_dialect'} = $self->dictionary->{$name};
+    return;
 }
 
-sub Feature    { $_[0]->_current_dialect->{'feature'}; }
-sub Rule       { $_[0]->_current_dialect->{'rule'}; }
-sub Scenario   { $_[0]->_current_dialect->{'scenario'}; }
-sub Background { $_[0]->_current_dialect->{'background'}; }
-sub Examples   { $_[0]->_current_dialect->{'examples'}; }
-sub Given      { $_[0]->_current_dialect->{'given'}; }
-sub When       { $_[0]->_current_dialect->{'when'}; }
-sub Then       { $_[0]->_current_dialect->{'then'}; }
-sub And        { $_[0]->_current_dialect->{'and'}; }
-sub But        { $_[0]->_current_dialect->{'but'}; }
+sub Feature    { return $_[0]->_current_dialect->{'feature'}; }
+sub Rule       { return $_[0]->_current_dialect->{'rule'}; }
+sub Scenario   { return $_[0]->_current_dialect->{'scenario'}; }
+sub Background { return $_[0]->_current_dialect->{'background'}; }
+sub Examples   { return $_[0]->_current_dialect->{'examples'}; }
+sub Given      { return $_[0]->_current_dialect->{'given'}; }
+sub When       { return $_[0]->_current_dialect->{'when'}; }
+sub Then       { return $_[0]->_current_dialect->{'then'}; }
+sub And        { return $_[0]->_current_dialect->{'and'}; }
+sub But        { return $_[0]->_current_dialect->{'but'}; }
 
 
 sub stepKeywordTypes {
     return @{ $_[0]->{'_step_keywords'}->{$_[1]} };
 }
 
 sub ScenarioOutline {
-    $_[0]->_current_dialect->{'scenarioOutline'};
+    return $_[0]->_current_dialect->{'scenarioOutline'};
 }
 
 1;
diff --git a/perl/lib/Gherkin/Exceptions.pm b/perl/lib/Gherkin/Exceptions.pm
@@ -3,7 +3,7 @@ use warnings;
 
 package Gherkin::Exceptions;
 
-sub stringify { my $self  = shift; $self->message }
+sub stringify { my $self  = shift; return $self->message; }
 sub throw     { my $class = shift; die $class->new(@_) }
 
 # Parent of single and composite exceptions
@@ -19,7 +19,7 @@ use Class::XSAccessor accessors => [qw/errors/];
 
 sub new {
     my ( $class, @errors ) = @_;
-    bless { errors => \@errors }, $class;
+    return bless { errors => \@errors }, $class;
 }
 
 sub message {
@@ -40,7 +40,7 @@ use Class::XSAccessor accessors => [qw/detailed_message location/];
 
 sub new {
     my ( $class, %args ) = @_;
-    bless { %args }, $class;
+    return bless { %args }, $class;
 }
 
 sub message {
diff --git a/perl/lib/Gherkin/Generated/Parser.pm b/perl/lib/Gherkin/Generated/Parser.pm
@@ -92,7 +92,7 @@ sub match_token {
     my ( $self, $state, $token, $context ) = @_;
     my $method_name = $states_to_match_names{ $state } ||
         die "Unknown state: $state";
-    $self->$method_name( $token, $context );
+    return $self->$method_name( $token, $context );
 }
 
 sub _construct_parser_error {
diff --git a/perl/lib/Gherkin/ParserBase.pm b/perl/lib/Gherkin/ParserBase.pm
@@ -15,7 +15,7 @@ use Gherkin::TokenScanner;
 
 sub new {
     my ( $class, $ast_builder, $token_matcher ) = @_;
-    bless {
+    return bless {
         ast_builder         => $ast_builder || Gherkin::AstBuilder->new(),
         token_matcher       => $token_matcher || Gherkin::TokenMatcher->new(),
         stop_at_first_error => 0,
@@ -40,6 +40,7 @@ sub add_error {
     my @errors = $context->errors;
     Gherkin::Exceptions::CompositeParser->throw(@errors)
       if @errors > $self->max_errors;
+    return;
 }
 
 sub _start_rule {
@@ -48,20 +49,23 @@ sub _start_rule {
     if (not eval { $self->ast_builder->start_rule( $ruleType ); 1 }) {
         $self->add_error( $context, $@ );
     }
+    return;
 }
 
 sub _end_rule {
     my ( $self, $context, $ruleType ) = @_;
     if (not eval { $self->ast_builder->end_rule( $ruleType ); 1 }) {
         $self->add_error( $context, $@ );
     }
+    return;
 }
 
 sub _build {
     my ( $self, $context, $token ) = @_;
     if (not eval { $self->ast_builder->build( $token ); 1 }) {
         $self->add_error( $context, $@ );
     }
+    return;
 }
 
 1;
diff --git a/perl/lib/Gherkin/ParserContext.pm b/perl/lib/Gherkin/ParserContext.pm
@@ -12,14 +12,15 @@ sub new {
     my ( $class, $options ) = @_;
     $options->{'token_queue'} ||= [];
     $options->{'_errors'}     ||= [];
-    bless $options, $class;
+    return bless $options, $class;
 }
 
-sub add_tokens { my $self = shift; push( @{ $self->token_queue }, @_ ); }
+sub add_tokens { my $self = shift; push( @{ $self->token_queue }, @_ ); return; }
 sub errors     { my $self = shift; return @{ $self->_errors } }
 sub add_errors {
     my $self = shift;
     push @{ $self->{'_errors'} }, @_;
+    return;
 }
 
 sub read_token {
diff --git a/perl/lib/Gherkin/Pickles/Compiler.pm b/perl/lib/Gherkin/Pickles/Compiler.pm
@@ -56,6 +56,7 @@ sub _compile_feature {
             }
         }
     }
+    return;
 }
 
 sub _compile_scenario {
@@ -90,6 +91,7 @@ sub _compile_scenario {
                 uri          => $uri,
                 ast_node_ids => [ $scenario->id ]
             )));
+    return;
 }
 
 sub _compile_scenario_outline {
@@ -146,6 +148,7 @@ sub _compile_scenario_outline {
                     )));
         }
     }
+    return;
 }
 
 sub _compile_rule {
@@ -176,6 +179,7 @@ sub _compile_rule {
             die "Unimplemented";
         }
     }
+    return;
 }
 
 sub _interpolate {
diff --git a/perl/lib/Gherkin/TokenFormatterBuilder.pm b/perl/lib/Gherkin/TokenFormatterBuilder.pm
@@ -8,13 +8,15 @@ sub reset {
     my $self = shift;
     $self->SUPER::reset();
     $self->{'formatted_tokens'} = [];
+    return;
 }
 
 sub formatted_tokens { return $_[0]->{'formatted_tokens'} }
 
 sub build {
     my ( $self, $token ) = @_;
     push( @{ $self->formatted_tokens }, $self->format_token($token) );
+    return;
 }
 
 sub start_rule { }
diff --git a/perl/lib/Gherkin/TokenMatcher.pm b/perl/lib/Gherkin/TokenMatcher.pm
@@ -33,9 +33,10 @@ sub _add_keyword_type_mappings {
         }
         push @{$keyword_types->{$keyword}}, $type;
     }
+    return;
 }
 
-sub dialect_name { $_[0]->dialect->dialect }
+sub dialect_name { return $_[0]->dialect->dialect; }
 sub change_dialect {
     my $self = shift;
     $self->dialect->change_dialect(@_);
@@ -51,46 +52,47 @@ sub change_dialect {
                                [ @{ $self->dialect->And }, @{ $self->dialect->But } ],
                                Cucumber::Messages::Step::KEYWORDTYPE_CONJUNCTION);
     $self->_keyword_types( $keyword_types );
+    return;
 }
 
 sub reset {
     my $self = shift;
     $self->change_dialect( $self->_default_dialect_name );
     $self->_indent_to_remove(0);
     $self->_active_doc_string_separator(undef);
-
+    return;
 }
 
 sub match_FeatureLine {
     my ( $self, $token ) = @_;
-    $self->_match_title_line( $token, FeatureLine => $self->dialect->Feature );
+    return $self->_match_title_line( $token, FeatureLine => $self->dialect->Feature );
 }
 
 sub match_RuleLine {
     my ( $self, $token ) = @_;
-    $self->_match_title_line( $token,
+    return $self->_match_title_line( $token,
         RuleLine => $self->dialect->Rule );
 }
 
 sub match_ScenarioLine {
     my ( $self, $token ) = @_;
-    $self->_match_title_line(
+    return $self->_match_title_line(
         $token,
         ScenarioLine => $self->dialect->Scenario )
-        or $self->_match_title_line(
+        || $self->_match_title_line(
             $token,
             ScenarioLine => $self->dialect->ScenarioOutline );
 }
 
 sub match_BackgroundLine {
     my ( $self, $token ) = @_;
-    $self->_match_title_line( $token,
+    return $self->_match_title_line( $token,
         BackgroundLine => $self->dialect->Background );
 }
 
 sub match_ExamplesLine {
     my ( $self, $token ) = @_;
-    $self->_match_title_line( $token,
+    return $self->_match_title_line( $token,
         ExamplesLine => $self->dialect->Examples );
 }
 
@@ -161,6 +163,7 @@ sub _set_token_matched {
 
     $token->location->{'column'} = $token->matched_indent + 1;
     $token->matched_gherkin_dialect( $self->dialect_name );
+    return;
 }
 
 sub match_EOF {
@@ -266,6 +269,7 @@ sub _match_DocStringSeparator {
 
     $self->_set_token_matched( $token,
         DocStringSeparator => { text => $content_type, keyword => $separator } );
+    return 1;
 }
 
 sub match_TableRow {
@@ -274,6 +278,7 @@ sub match_TableRow {
 
     $self->_set_token_matched( $token,
         TableRow => { items => $token->line->table_cells } );
+    return 1;
 }
 
 1;

Original file line number	Diff line number	Diff line change
`@@ -18,6 +18,7 @@ sub run {`
`18`	`18`	`print $fh join "\n", @{ $parser->parse($_) } for @file_list;`
`19`	`19`	`print $fh "\n";`
`20`	`20`
	`21`	`+ return;`
`21`	`22`	`}`
`22`	`23`
`23`	`24`	`__PACKAGE__->run(\*STDOUT, @ARGV) unless caller;`
Original file line number	Diff line number	Diff line change
`@@ -83,7 +83,7 @@ sub match_token {`
`83`	`83`	`my ( $self, $state, $token, $context ) = @@_;`
`84`	`84`	`my $method_name = $states_to_match_names{ $state } \|\|`
`85`	`85`	`die "Unknown state: $state";`
`86`		`- $self->$method_name( $token, $context );`
	`86`	`+ return $self->$method_name( $token, $context );`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`sub _construct_parser_error {`
Original file line number	Diff line number	Diff line change
`@@ -59,6 +59,7 @@ sub from_paths {`
`59`	`59`	`$id_generator,`
`60`	`60`	`$sink);`
`61`	`61`	`}`
	`62`	`+ return;`
`62`	`63`	`}`
`63`	`64`
`64`	`65`	`sub _parse_source_encoding_header {`
`@@ -82,6 +83,7 @@ sub _parse_source_encoding_header {`
`82`	`83`	`unless $enc;`
`83`	`84`	`$source->data( $enc->decode(encode_utf8($source->data)) );`
`84`	`85`	`}`
	`86`	`+ return;`
`85`	`87`	`}`
`86`	`88`
`87`	`89`	`sub _parser_error_message {`
`@@ -121,7 +123,7 @@ sub from_source {`
`121`	`123`	`$sink->($ast_msg) if $self->include_ast;`
`122`	`124`
`123`	`125`	`if ($self->include_pickles) {`
`124`		`- Gherkin::Pickles::Compiler->compile(`
	`126`	`+ return Gherkin::Pickles::Compiler->compile(`
`125`	`127`	`$ast_msg,`
`126`	`128`	`$id_generator,`
`127`	`129`	`$sink);`
`@@ -142,6 +144,7 @@ sub from_source {`
`142`	`144`	`die $@; # rethrow`
`143`	`145`	`}`
`144`	`146`	`}`
	`147`	`+ return;`
`145`	`148`	`}`
`146`	`149`
`147`	`150`
Original file line number	Diff line number	Diff line change
`@@ -27,14 +27,15 @@ sub new {`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`# Simple builder sugar`
`30`		`-sub ast_node { Gherkin::AstNode->new( $_[0] ) }`
	`30`	`+sub ast_node { return Gherkin::AstNode->new( $_[0] ); }`
`31`	`31`
`32`	`32`	`sub reset {`
`33`	`33`	`my $self = shift;`
`34`	`34`	`my ($uri) = @_;`
`35`	`35`	`$self->{'stack'} = [ ast_node('None') ];`
`36`	`36`	`$self->{'comments'} = [];`
`37`	`37`	`$self->{'uri'} = $uri;`
	`38`	`+ return;`
`38`	`39`	`}`
`39`	`40`
`40`	`41`	`sub current_node {`
`@@ -45,12 +46,14 @@ sub current_node {`
`45`	`46`	`sub start_rule {`
`46`	`47`	`my ( $self, $rule_type ) = @_;`
`47`	`48`	`push( @{ $self->{'stack'} }, ast_node($rule_type) );`
	`49`	`+ return;`
`48`	`50`	`}`
`49`	`51`
`50`	`52`	`sub end_rule {`
`51`	`53`	`my ( $self, $rule_type ) = @_;`
`52`	`54`	`my $node = pop( @{ $self->{'stack'} } );`
`53`	`55`	`$self->current_node->add( $node->rule_type, $self->transform_node($node) );`
	`56`	`+ return;`
`54`	`57`	`}`
`55`	`58`
`56`	`59`	`sub build {`
`@@ -64,6 +67,7 @@ sub build {`
`64`	`67`	`} else {`
`65`	`68`	`$self->current_node->add( $token->matched_type, $token );`
`66`	`69`	`}`
	`70`	`+ return;`
`67`	`71`	`}`
`68`	`72`
`69`	`73`	`sub get_result {`
`@@ -134,6 +138,7 @@ sub ensure_cell_count {`
`134`	`138`	`$row->location );`
`135`	`139`	`}`
`136`	`140`	`}`
	`141`	`+ return;`
`137`	`142`	`}`
`138`	`143`
`139`	`144`	`sub get_cells {`
Original file line number	Diff line number	Diff line change
`@@ -7,12 +7,13 @@ use Class::XSAccessor accessors => [ qw/rule_type/, ];`
`7`	`7`
`8`	`8`	`sub new {`
`9`	`9`	`my ( $class, $rule_type ) = @_;`
`10`		`- bless { rule_type => $rule_type, _sub_items => {} }, $class;`
	`10`	`+ return bless { rule_type => $rule_type, _sub_items => {} }, $class;`
`11`	`11`	`}`
`12`	`12`
`13`	`13`	`sub add {`
`14`	`14`	`my ( $self, $rule_type, $obj ) = @_;`
`15`	`15`	`push( @{ ( $self->{'_sub_items'}->{$rule_type} \|\|= [] ) }, $obj );`
	`16`	`+ return;`
`16`	`17`	`}`
`17`	`18`
`18`	`19`	`sub get_single {`
Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,7 @@ sub match_token {`
`92`	`92`	`my ( $self, $state, $token, $context ) = @_;`
`93`	`93`	`my $method_name = $states_to_match_names{ $state } \|\|`
`94`	`94`	`die "Unknown state: $state";`
`95`		`- $self->$method_name( $token, $context );`
	`95`	`+ return $self->$method_name( $token, $context );`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`sub _construct_parser_error {`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ use Gherkin::TokenScanner;`
`15`	`15`
`16`	`16`	`sub new {`
`17`	`17`	`my ( $class, $ast_builder, $token_matcher ) = @_;`
`18`		`- bless {`
	`18`	`+ return bless {`
`19`	`19`	`ast_builder => $ast_builder \|\| Gherkin::AstBuilder->new(),`
`20`	`20`	`token_matcher => $token_matcher \|\| Gherkin::TokenMatcher->new(),`
`21`	`21`	`stop_at_first_error => 0,`
`@@ -40,6 +40,7 @@ sub add_error {`
`40`	`40`	`my @errors = $context->errors;`
`41`	`41`	`Gherkin::Exceptions::CompositeParser->throw(@errors)`
`42`	`42`	`if @errors > $self->max_errors;`
	`43`	`+ return;`
`43`	`44`	`}`
`44`	`45`
`45`	`46`	`sub _start_rule {`
`@@ -48,20 +49,23 @@ sub _start_rule {`
`48`	`49`	`if (not eval { $self->ast_builder->start_rule( $ruleType ); 1 }) {`
`49`	`50`	`$self->add_error( $context, $@ );`
`50`	`51`	`}`
	`52`	`+ return;`
`51`	`53`	`}`
`52`	`54`
`53`	`55`	`sub _end_rule {`
`54`	`56`	`my ( $self, $context, $ruleType ) = @_;`
`55`	`57`	`if (not eval { $self->ast_builder->end_rule( $ruleType ); 1 }) {`
`56`	`58`	`$self->add_error( $context, $@ );`
`57`	`59`	`}`
	`60`	`+ return;`
`58`	`61`	`}`
`59`	`62`
`60`	`63`	`sub _build {`
`61`	`64`	`my ( $self, $context, $token ) = @_;`
`62`	`65`	`if (not eval { $self->ast_builder->build( $token ); 1 }) {`
`63`	`66`	`$self->add_error( $context, $@ );`
`64`	`67`	`}`
	`68`	`+ return;`
`65`	`69`	`}`
`66`	`70`
`67`	`71`	`1;`