From 005676005f0838dbecbd940468e9f86b3d4b5b49 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Fri, 30 Jan 2015 14:14:22 -0800
Subject: [PATCH] Adding test

---
 .../typeArgumentInferenceWithObjectLiteral.js | 34 ++++++++++
 ...peArgumentInferenceWithObjectLiteral.types | 65 +++++++++++++++++++
 .../typeArgumentInferenceWithObjectLiteral.ts | 18 +++++
 3 files changed, 117 insertions(+)
 create mode 100644 tests/baselines/reference/typeArgumentInferenceWithObjectLiteral.js
 create mode 100644 tests/baselines/reference/typeArgumentInferenceWithObjectLiteral.types
 create mode 100644 tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithObjectLiteral.ts

diff --git a/tests/baselines/reference/typeArgumentInferenceWithObjectLiteral.js b/tests/baselines/reference/typeArgumentInferenceWithObjectLiteral.js
new file mode 100644
index 00000000000..e3105130a74
--- /dev/null
+++ b/tests/baselines/reference/typeArgumentInferenceWithObjectLiteral.js
@@ -0,0 +1,34 @@
+//// [typeArgumentInferenceWithObjectLiteral.ts]
+interface Computed<T> {
+    read(): T;
+    write(value: T);
+}
+
+function foo<T>(x: Computed<T>) { }
+
+var s: string;
+
+// Calls below should infer string for T and then assign that type to the value parameter
+foo({
+    read: () => s,
+    write: value => s = value
+});
+foo({
+    write: value => s = value,
+    read: () => s
+});
+
+
+//// [typeArgumentInferenceWithObjectLiteral.js]
+function foo(x) {
+}
+var s;
+// Calls below should infer string for T and then assign that type to the value parameter
+foo({
+    read: function () { return s; },
+    write: function (value) { return s = value; }
+});
+foo({
+    write: function (value) { return s = value; },
+    read: function () { return s; }
+});
diff --git a/tests/baselines/reference/typeArgumentInferenceWithObjectLiteral.types b/tests/baselines/reference/typeArgumentInferenceWithObjectLiteral.types
new file mode 100644
index 00000000000..5cf2eac0418
--- /dev/null
+++ b/tests/baselines/reference/typeArgumentInferenceWithObjectLiteral.types
@@ -0,0 +1,65 @@
+=== tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithObjectLiteral.ts ===
+interface Computed<T> {
+>Computed : Computed<T>
+>T : T
+
+    read(): T;
+>read : () => T
+>T : T
+
+    write(value: T);
+>write : (value: T) => any
+>value : T
+>T : T
+}
+
+function foo<T>(x: Computed<T>) { }
+>foo : <T>(x: Computed<T>) => void
+>T : T
+>x : Computed<T>
+>Computed : Computed<T>
+>T : T
+
+var s: string;
+>s : string
+
+// Calls below should infer string for T and then assign that type to the value parameter
+foo({
+>foo({    read: () => s,    write: value => s = value}) : void
+>foo : <T>(x: Computed<T>) => void
+>{    read: () => s,    write: value => s = value} : { read: () => string; write: (value: string) => string; }
+
+    read: () => s,
+>read : () => string
+>() => s : () => string
+>s : string
+
+    write: value => s = value
+>write : (value: string) => string
+>value => s = value : (value: string) => string
+>value : string
+>s = value : string
+>s : string
+>value : string
+
+});
+foo({
+>foo({    write: value => s = value,    read: () => s}) : void
+>foo : <T>(x: Computed<T>) => void
+>{    write: value => s = value,    read: () => s} : { write: (value: string) => string; read: () => string; }
+
+    write: value => s = value,
+>write : (value: string) => string
+>value => s = value : (value: string) => string
+>value : string
+>s = value : string
+>s : string
+>value : string
+
+    read: () => s
+>read : () => string
+>() => s : () => string
+>s : string
+
+});
+
diff --git a/tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithObjectLiteral.ts b/tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithObjectLiteral.ts
new file mode 100644
index 00000000000..249700fb33e
--- /dev/null
+++ b/tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithObjectLiteral.ts
@@ -0,0 +1,18 @@
+interface Computed<T> {
+    read(): T;
+    write(value: T);
+}
+
+function foo<T>(x: Computed<T>) { }
+
+var s: string;
+
+// Calls below should infer string for T and then assign that type to the value parameter
+foo({
+    read: () => s,
+    write: value => s = value
+});
+foo({
+    write: value => s = value,
+    read: () => s
+});