// Copyright (c) 2019, 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.

// Test how spread interacts with inference.
import 'package:expect/expect.dart';

void main() {
  testBottomUpInference();
  testTopDownInference();
}

void testBottomUpInference() {
  // Lists.
  Expect.type<List<dynamic>>([...[]]);
  Expect.type<List<int>>([...<int>[]]);
  Expect.type<List<int>>([
    ...[1],
  ]);
  Expect.type<List<int>>([
    1,
    ...[2],
  ]);
  Expect.type<List<num>>([
    1,
    ...[0.2],
  ]);
  Expect.type<List<int>>([
    ...[1, 2],
  ]);
  Expect.type<List<num>>([
    ...[1, 0.2],
  ]);
  Expect.type<List<int>>([
    ...[1],
    ...[2],
  ]);
  Expect.type<List<num>>([
    ...[1],
    ...[0.2],
  ]);

  // Maps.
  Expect.type<Map<dynamic, dynamic>>({...{}});
  Expect.type<Map<int, int>>({...<int, int>{}});
  Expect.type<Map<int, int>>({
    ...{1: 1},
  });
  Expect.type<Map<int, int>>({
    1: 1,
    ...{2: 2},
  });
  Expect.type<Map<num, num>>({
    1: 1,
    ...{0.2: 0.2},
  });
  Expect.type<Map<int, int>>({
    ...{1: 1, 2: 2},
  });
  Expect.type<Map<num, num>>({
    ...{1: 1, 0.2: 0.2},
  });
  Expect.type<Map<int, int>>({
    ...{1: 1},
    ...{2: 2},
  });
  Expect.type<Map<num, num>>({
    ...{1: 1},
    ...{0.2: 0.2},
  });

  // Sets.
  Expect.type<Set<dynamic>>({...[]});
  Expect.type<Set<int>>({...<int>[]});
  Expect.type<Set<int>>({
    ...[1],
  });
  Expect.type<Set<int>>({
    1,
    ...[2],
  });
  Expect.type<Set<num>>({
    1,
    ...[0.2],
  });
  Expect.type<Set<int>>({
    ...[1, 2],
  });
  Expect.type<Set<num>>({
    ...[1, 0.2],
  });
  Expect.type<Set<int>>({
    ...[1],
    ...[2],
  });
  Expect.type<Set<num>>({
    ...[1],
    ...[0.2],
  });
  Expect.type<Set<num>>({
    ...{1},
    ...[0.2],
  });
  Expect.type<Set<num>>({
    ...{1},
    ...{0.2},
  });

  // If the iterable's type is dynamic, the element type is inferred as dynamic.
  Expect.type<List<dynamic>>([...([] as dynamic)]);
  Expect.type<Set<dynamic>>({1, ...([] as dynamic)});

  // If the iterable's type is dynamic, the key and value types are inferred as
  // dynamic.
  Expect.type<Map<dynamic, dynamic>>({1: 1, ...({} as dynamic)});
}

void testTopDownInference() {
  // Lists.
  Iterable<T> expectIntIterable<T>() {
    Expect.equals(int, T);
    return [];
  }

  Iterable<T> expectDynamicIterable<T>() {
    Expect.equals(dynamic, T);
    return [];
  }

  // The context element type is pushed into the spread expression if it is
  // Iterable<T>.
  Expect.listEquals(<int>[], <int>[...expectIntIterable()]);

  // Bottom up-inference from elements is not pushed back down into spread.
  Expect.listEquals(<int>[1], [1, ...expectDynamicIterable()]);

  // Maps.
  Map<K, V> expectIntStringMap<K, V>() {
    Expect.equals(int, K);
    Expect.equals(String, V);
    return {};
  }

  Map<K, V> expectDynamicDynamicMap<K, V>() {
    Expect.equals(dynamic, K);
    Expect.equals(dynamic, V);
    return {};
  }

  // The context element type is pushed into the spread expression if it is
  // Map<K, V>.
  Expect.mapEquals(<int, String>{}, <int, String>{...expectIntStringMap()});

  // Bottom up-inference from elements is not pushed back down into spread.
  Expect.mapEquals(
    <int, String>{1: "s"},
    {1: "s", ...expectDynamicDynamicMap()},
  );

  // Sets.
  Set<T> expectIntSet<T>() {
    Expect.equals(int, T);
    return Set();
  }

  Set<T> expectDynamicSet<T>() {
    Expect.equals(dynamic, T);
    return Set();
  }

  // The context element type is pushed into the spread expression if it is
  // Iterable<T>.
  Expect.setEquals(<int>{}, <int>{...expectIntSet()});

  // Bottom up-inference from elements is not pushed back down into spread.
  Expect.setEquals(<int>{1}, {1, ...expectDynamicSet()});
}