pkg/linter/lib/src/rules/matching_super_parameters.dart

// Copyright (c) 2023, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

import 'package:analyzer/analysis_rule/analysis_rule.dart';
import 'package:analyzer/analysis_rule/rule_context.dart';
import 'package:analyzer/analysis_rule/rule_visitor_registry.dart';
import 'package:analyzer/dart/ast/ast.dart';
import 'package:analyzer/dart/ast/visitor.dart';
import 'package:analyzer/dart/element/element.dart';
import 'package:analyzer/error/error.dart';

import '../analyzer.dart';
import '../diagnostic.dart' as diag;

const _desc = r'Use matching super parameter names.';

class MatchingSuperParameters extends AnalysisRule {
  new() : super(name: LintNames.matching_super_parameters, description: _desc);

  @override
  DiagnosticCode get diagnosticCode => diag.matchingSuperParameters;

  @override
  void registerNodeProcessors(
    RuleVisitorRegistry registry,
    RuleContext context,
  ) {
    var visitor = _Visitor(this);
    registry.addConstructorDeclaration(this, visitor);
    registry.addPrimaryConstructorDeclaration(this, visitor);
  }
}

class _Visitor extends SimpleAstVisitor<void> {
  final AnalysisRule rule;

  const new(this.rule);

  @override
  void visitConstructorDeclaration(ConstructorDeclaration node) {
    _visitConstructor(node.parameters, node.initializers, node.parent?.parent);
  }

  @override
  void visitPrimaryConstructorDeclaration(PrimaryConstructorDeclaration node) {
    _visitConstructor(
      node.formalParameters,
      node.body?.initializers,
      node.parent,
    );
  }

  void _visitConstructor(
    FormalParameterList parameterList,
    List<ConstructorInitializer>? initializers,
    AstNode? parent,
  ) {
    var positionalSuperParameters = <SuperFormalParameter>[];
    for (var parameter in parameterList.parameters) {
      if (parameter is SuperFormalParameter && parameter.isPositional) {
        positionalSuperParameters.add(parameter);
      }
    }
    if (positionalSuperParameters.isEmpty) {
      // We are only concerned with positional super-parameters.
      return;
    }
    var superInvocation = initializers
        ?.whereType<SuperConstructorInvocation>()
        .firstOrNull;
    var superConstructor = superInvocation?.element;
    if (superConstructor == null) {
      if (parent is ClassDeclaration) {
        superConstructor = parent
            .declaredFragment
            ?.element
            .supertype
            ?.element
            .unnamedConstructor;
      }
    }
    if (superConstructor is! ConstructorElement) return;

    var positionalParametersOfSuper = superConstructor.formalParameters
        .where((p) => p.isPositional)
        .toList();
    if (positionalParametersOfSuper.length < positionalSuperParameters.length) {
      // More positional parameters are passed to super constructor than it
      // has positional parameters, an error.
      return;
    }
    for (var i = 0; i < positionalSuperParameters.length; i++) {
      var superParameter = positionalSuperParameters[i];
      var superParameterName = superParameter.name.lexeme;
      var parameterOfSuperName = positionalParametersOfSuper[i].name;
      if (parameterOfSuperName != null &&
          superParameterName != parameterOfSuperName) {
        rule.reportAtNode(
          superParameter,
          arguments: [superParameterName, parameterOfSuperName],
        );
      }
    }
  }
}