Experimental flag and fix basic constructors

compiler/options.nim

@@ -219,7 +219,8 @@ type
     unicodeOperators, # deadcode
     flexibleOptionalParams,
     strictDefs,
-    strictCaseObjects
+    strictCaseObjects,
+    inferGenericTypes
 
   LegacyFeature* = enum
     allowSemcheckedAstModification,

compiler/semcall.nim

@@ -562,18 +562,27 @@ proc getCallLineInfo(n: PNode): TLineInfo =
     discard
   result = n.info
 
-proc inheritBindings(x: TCandidate, expectedType: PType): TIdTable =
-  ## helper proc to inherit bound generic parameters from expectedType into a new TIdTable
+proc inheritBindings(c: PContext, x: TCandidate, expectedType: PType): TIdTable =
+  ## Helper proc to inherit bound generic parameters from expectedType into a new TIdTable.
+  ## Returns existing bindings if 'inferGenericTypes' isn't in c.features
   result = x.bindings
-  if expectedType != nil and expectedType.sons.len() > 0 and expectedType.sons[0] != nil:
-    let y = x.calleeSym.ast[genericParamsPos]
-    # concrete types give us just the list of generic params
+  if inferGenericTypes notin c.features: return
+  if expectedType == nil: return
+
+  let y = x.calleeSym.ast[genericParamsPos]
+  if expectedType.sons.len() > 0 and expectedType.sons[0] != nil:
+    #let y = x.calleeSym.ast[genericParamsPos]
+    # concrete types provide just the list of generic params
     let startIdx = if expectedType.kind in ConcreteTypes: 0 else: 1
     for i in startIdx ..< expectedType.len-startIdx:
       let j = i - startIdx # idx of unbound param in callee
       if result.idTableGet(y[j].typ) != nil:
-        break # let's not overwrite existing ones
+        break # don't not overwrite existing ones
       result.idTablePut(y[j].typ, expectedType[i])
+  elif expectedType.sons.len() == 0 and y.len() == 1:
+    # Already a base type, just pass it along
+    if result.idTableGet(y[0].typ) == nil:
+      result.idTablePut(y[0].typ, expectedType)
 
 proc semResolvedCall(c: PContext, x: TCandidate,
                      n: PNode, flags: TExprFlags;
@@ -597,11 +606,11 @@ proc semResolvedCall(c: PContext, x: TCandidate,
       if x.calleeSym.magic in {mArrGet, mArrPut}:
         finalCallee = x.calleeSym
       else:
-        finalCallee = generateInstance(c, x.calleeSym, x.inheritBindings(expectedType), n.info)
+        finalCallee = generateInstance(c, x.calleeSym, c.inheritBindings(x, expectedType), n.info)
     else:
       # For macros and templates, the resolved generic params
       # are added as normal params.
-      for s in instantiateGenericParamList(c, gp, x.inheritBindings(expectedType)):
+      for s in instantiateGenericParamList(c, gp, c.inheritBindings(x, expectedType)):
         case s.kind
         of skConst:
           if not s.astdef.isNil:

doc/manual.md

@@ -5749,7 +5749,7 @@ Inferred generic parameters
 ---------------------------
 
 In expressions making use of generic procs or templates, the expected
-(unbound) types are often able to be inferred based on context.
+(unbound) types are often able to be inferred based on context:
 
   ```nim  test = "nim c $1"
   import std/options
@@ -5782,10 +5782,10 @@ that would be necessary at the given location.
 
 If that is the case, the unmapped generic parameters are mapped to the expected ones.
 
-If bindings cannot be inferred, compilation will fail and manual specification is required.
+If bindings *cannot be inferred*, compilation will fail and manual specification is required.
 
-A limitation of this approach is that an expression as part of a function call
-is unable to be inferred and has to be specified:
+An example for failing inference can be found when passing a generic expression
+to a function/template call:
 
   ```nim  test = "nim c $1"  status = 1
   proc myProc[T](a, b: T) = discard

tests/generics/treturn_inference.nim

@@ -1,4 +1,7 @@
 
+{.experimental: "inferGenericTypes".}
+
+
 block:
   type
     MyOption[T, Z] = object
@@ -75,4 +78,25 @@ block:
     for i in 0 .. N.high:
       result[i] = i
   var x: array[2, int] = giveArray()
-  doAssert x == [0, 1]
+  doAssert x == [0, 1]
+
+
+# basic constructors
+block:
+  type MyType[T] = object
+    x: T
+
+  proc giveValue[T](): T =
+    when T is int:
+      12
+    else:
+      default(T)
+
+  let x = MyType[int](x : giveValue())
+  doAssert x.x is int
+  doAssert x.x == 12
+
+  let y = MyType[MyType[float]](x : MyType[float](x : giveValue()))
+  doAssert y.x is MyType[float]
+  doAssert y.x.x is float
+  doAssert y.x.x == 0.0