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

// @dart = 2.9

/// @assertion Functions include function declarations, methods, getters,
/// setters, constructors and function literals.
/// All functions have a signature and a body.
/// functionSignature:
///   metadata returnType? identifier formalParameterList
/// ;
/// returnType: void | type
/// ;
/// functionBody:
///   async? '=>' expression ';' | (async | async* | sync*)? block
/// ;
/// block:
///   '{' statements '}'
/// ;
///
/// @description Checks that any specified expression can be a body
/// of a function of the form [functionSignature '=>' expression ';']
///
/// @author msyabro

import "syntax_t03_lib.dart" as prfx;

class A {
  const A();

  static final a = 1;
}

class B {
  var p;

  //This
  method() => this;
  B() {}
}

main() {
  int x = 1;
  int y = 10;
  B b = new B();
  List l = new List.from([1, 2]);

  //Constants
  f_const() => const {"a" : 1, "b" : 2, "c" : 3};
  g_const() => const [];

  //null
  f_null() => null;

  //Numbers
  f_num() => 1;
  g_num() => -.0;
  h_num() => 0xa;

  //Booleans
  f_bool() => true;
  g_bool() => false;

  //Strings
  f_string() => "";
  g_string() => "str";
  h_string() => "$x";

  //Lists
  f_list() => [];
  g_list() => [1, "2"];

  //Maps
  f_map() => {"1" : 1, "2": 2};

  //Function expressions
  f_func() => (int z) {return z + 1;};

  // only one semicolon is fine here because the nested function expression
  // is not a statement and is parsed using a different grammar production
  g_func() => () => 1;

  //Instance creation
  f_instance() => new B();
  g_instance() => const A();

  //Property extraction
  f_property() => b.p;
  g_property() => b.method;

  //Function invocation
  f_fInvocation() => f_property();

  //Method invocation
  f_mInvocation() => b.method();

  //Assignment
  f_assignment() => x = 3;
  g_assignment() => x *= 2;

  //Conditional
  f_conditional() => (1 > 0) ? (x = 2) : (x = 5);

  //Logical boolean expressions
  f_logical() => x > 1 && y < 2;
  g_logical() => x < 2 || y == 3;

  //Bitwise expressions
  f_bitwise() => x & y;
  g_bitwise() => x | y;
  h_bitwise() => x ^ y;

  //Equality
  f_equality() => x == y;
  g_equality() => identical(x, y);
  h_equality() => !identical(x, y);
  i_equality() => x != y;

  //Relational expressions
  f_relational() => x > y;
  g_relational() => y <= x;

  //Shift
  f_shift() => x << 1;
  g_shift() => y >> 2;

  //Additive expressions
  f_additive() => x + y;
  g_additive() => x - y;

  //Multiplicative expressions
  f_multiplicative() => x * y;
  g_multiplicative() => x / y;
  h_multiplicative() => x ~/ y;
  i_multiplicative() => x % y;

  //Unary expressions
  f_unari() => ++x;
  g_unari() => x--;
  h_unari() => -y;

  //Assignable expressions
  f_assignable() => l[1];

  //Identifier reference
  f_identifier() => x;
  g_identifier() => b;
  h_identifier() => prfx.foo;

  //Type test
  f_type() => x is String;
  g_type() => f_type is Function;

  // now call every function to force the compiler to parse it
  new B().method();
  //Constants
  f_const();
  g_const();

  //null
  f_null();

  //Numbers
  f_num();
  g_num();
  h_num();

  //Booleans
  f_bool();
  g_bool();

  //Strings
  f_string();
  g_string();
  h_string();

  //Lists
  f_list();
  g_list();

  //Maps
  f_map();

  //Function expressions
  f_func();

  g_func();

  //Instance creation
  f_instance();
  g_instance();

  //Property extraction
  f_property();
  g_property();

  //Function invocation
  f_fInvocation();

  //Method invocation
  f_mInvocation();

  //Assignment
  f_assignment();
  g_assignment();

  //Conditional
  f_conditional();

  //Logical boolean expressions
  f_logical();
  g_logical();

  //Bitwise expressions
  f_bitwise();
  g_bitwise();
  h_bitwise();

  //Equality
  f_equality();
  g_equality();
  h_equality();
  i_equality();

  //Relational expressions
  f_relational();
  g_relational();

  //Shift
  f_shift();
  g_shift();

  //Additive expressions
  f_additive();
  g_additive();

  //Multiplicative expressions
  f_multiplicative();
  g_multiplicative();
  h_multiplicative();
  i_multiplicative();

  //Unary expressions
  f_unari();
  g_unari();
  h_unari();

  //Assignable expressions
  f_assignable();

  //Identifier reference
  f_identifier();
  g_identifier();
  h_identifier();

  //Type test
  f_type();
  g_type();
}