generateAccessorMethods method

void generateAccessorMethods(List<Method> extMethods)

Implementation

void generateAccessorMethods(List<Method> extMethods) {
  if (!generateAccessors) return;
  final usedTypes = <ImportableType>{};
  for (final dep in dependencies) {
    if (dep.isFromModule || !usedTypes.add(dep.typeImpl)) {
      continue;
    }
    final passesArgs = dep.dependencies.any((d) => d.isFactoryParam) || dep.instanceName != null;
    final isAsyncOrHasAsyncDep = dep.isAsync || dep.dependencies.any(dependencies.isAsyncOrHasAsyncDependency);
    final returns = isAsyncOrHasAsyncDep
        ? TypeReference(
            (b) => b
              ..symbol = 'Future'
              ..types.add(typeRefer(dep.typeImpl, targetFile)),
          )
        : typeRefer(dep.typeImpl, targetFile);
    extMethods.add(
      Method(
        (b) {
          b
            ..name = toCamelCase(dep.typeImpl.name)
            ..returns = returns
            ..type = passesArgs ? null : MethodType.getter
            ..lambda = true;
          // add parameters for factory params
          if (dep.instanceName != null) {
            b.optionalParameters.add(
              Parameter(
                (pb) => pb
                  ..named = true
                  ..name = 'instanceName'
                  ..type = nullableRefer('String', nullable: true),
              ),
            );
          }
          for (final iDep in dep.dependencies.where((d) => d.isFactoryParam)) {
            b.optionalParameters.add(
              Parameter(
                (pb) => pb
                  ..required = iDep.isRequired && !iDep.type.isNullable
                  ..named = true
                  ..name = iDep.paramName
                  ..type = typeRefer(iDep.type, targetFile),
              ),
            );
          }

          int paramIndex = 0;
          b.body =
              refer(
                    isAsyncOrHasAsyncDep ? 'getAsync' : 'get',
                  )
                  .call(
                    [],
                    {
                      if (dep.instanceName != null) 'instanceName': refer('instanceName'),
                      for (final iDep in dep.dependencies.where((d) => d.isFactoryParam))
                        'param${++paramIndex}': refer(iDep.paramName),
                    },
                    [typeRefer(dep.typeImpl, targetFile)],
                  )
                  .code;
        },
      ),
    );
  }
}