/* -----------------------------------------------------------------------------
Copyright 2020-2021 Kevin P. Barry

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
----------------------------------------------------------------------------- */

// Author: Kevin P. Barry [ta0kira@gmail.com]

testcase "internal merge" {
  success
}

unittest test {
  \ Value.create().call().call()
}

@value interface Interface {
  call () -> (Interface)
}

concrete Value {
  refines Interface
  @type create () -> (Value)
}

define Value {
  create () {
    return Value{}
  }

  @value call () -> (Value)
  call () {
    return self
  }
}


testcase "internal merge failed" {
  error
  require "Interface2"
}

@value interface Interface { }

@value interface Interface2 {
  refines Interface
  call () -> (Interface2)
}

concrete Value {
  refines Interface2
  @type create () -> (Value)
}

define Value {
  create () {
    return Value{}
  }

  @value call () -> (Interface)
  call () {
    return self
  }
}


testcase "external merge" {
  success
}

unittest test {
  \ Value.create().call().call()
}

@value interface Interface {
  call () -> (Interface)
}

concrete Value {
  refines Interface
  @type create () -> (Value)
  @value call () -> (Value)
}

define Value {
  create () {
    return Value{}
  }

  call () {
    return self
  }
}


testcase "external merge failed" {
  error
  require "Interface2"
}

@value interface Interface { }

@value interface Interface2 {
  refines Interface
  call () -> (Interface2)
}

concrete Value {
  refines Interface2
  @type create () -> (Value)
  @value call () -> (Interface)
}

define Value {
  create () {
    return Value{}
  }

  call () {
    return self
  }
}


testcase "merging of internal inherited functions works" {
  compiles
}

@value interface Base0 {
  call (Int) -> ()
}

@value interface Base1 {
  call (String) -> ()
}

concrete Type { }

define Type {
  refines Base0
  refines Base1

  @value call (Formatted) -> ()
  call (_) { }
}


testcase "merging of internal/public inherited functions works" {
  compiles
}

@value interface Base0 {
  call (Int) -> ()
}

@value interface Base1 {
  call (String) -> ()
}

concrete Type {
  refines Base0
}

define Type {
  refines Base1

  @value call (Formatted) -> ()
  call (_) { }
}


testcase "public merge does not interfere with internal merge" {
  compiles
}

@value interface Base0 {
  call (Int) -> ()
}

@value interface Base1 {
  call (String) -> ()
}

concrete Type {
  refines Base0
  refines Base1

  @value call (Formatted) -> ()
}

define Type {
  @value call (any) -> ()
  call (_) { }
}


testcase "public function used for internal merge" {
  compiles
}

@value interface Base0 {
  call (Int) -> ()
}

@value interface Base1 {
  call (String) -> ()
}

concrete Type {
  @value call (Formatted) -> ()
}

define Type {
  refines Base0
  refines Base1

  call (_) { }
}


testcase "public merge conflicts with internal merge" {
  error
  require "any"
  require "Formatted"
  require "call"
}

@value interface Base0 {
  call (Int) -> ()
}

@value interface Base1 {
  call (String) -> ()
}

concrete Type {
  refines Base0
  refines Base1

  @value call (any) -> ()
}

define Type {
  @value call (Formatted) -> ()
  call (_) { }
}


testcase "public merge invalid for internal merge" {
  error
  require "Int"
  require "String"
  require "Float"
  require "call"
}

@value interface Base0 {
  call (Int) -> ()
}

@value interface Base1 {
  call (String) -> ()
}

concrete Type {
  @value call (Float) -> ()
}

define Type {
  refines Base0
  refines Base1

  call (_) { }
}


testcase "public and internal merges both required" {
  compiles
}

@value interface Base0 {
  call (Int) -> ()
}

@value interface Base1 {
  call (String) -> ()
}

@value interface Base2 {
  call (Base2) -> ()
}

@value interface Base3 {
  call (Base3) -> ()
}

concrete Type {
  refines Base0
  refines Base1

  @value call (Formatted) -> ()
}

define Type {
  refines Base2
  refines Base3

  @value call (any) -> ()
  call (_) { }
}


testcase "public and internal merges both required but internal missing" {
  error
  require "Base2"
  require "Base3"
  require "Formatted"
  exclude "Int"
  exclude "String"
}

@value interface Base0 {
  call (Int) -> ()
}

@value interface Base1 {
  call (String) -> ()
}

@value interface Base2 {
  call (Base2) -> ()
}

@value interface Base3 {
  call (Base3) -> ()
}

concrete Type {
  refines Base0
  refines Base1

  @value call (Formatted) -> ()
}

define Type {
  refines Base2
  refines Base3

  call (_) { }
}