Florian Ragwitz pushed to branch wip/rafl/meaningful-main-return at Glasgow Haskell Compiler / GHC

Commits:

1 changed file:

Changes:

  • compiler/GHC/Tc/Module.hs
    ... ... @@ -2042,35 +2042,36 @@ generateMainBinding tcg_env main_name = do
    2042 2042
     -- https://github.com/ghc-proposals/ghc-proposals/pull/771.
    
    2043 2043
     handleMainReturn :: Name -> TcType -> TcEvBinds -> LHsExpr GhcTc -> TcM (LHsExpr GhcTc)
    
    2044 2044
     handleMainReturn main_name res_ty ev_binds main_expr = do
    
    2045
    -  meaningful_main <- xoptM LangExt.MeaningfulMainReturn
    
    2046
    -  void_ty <- mkTyConTy <$> tcLookupKnownOccTyCon voidTyConOcc
    
    2047
    -  exit_code_ty <- mkTyConTy <$> tcLookupKnownOccTyCon exitCodeTyConOcc
    
    2048
    -  main_res_ty <- liftZonkM $ zonkTcType res_ty
    
    2049
    -
    
    2050
    -  let unit_valid = isJust (tcUnifyTy main_res_ty unitTy)
    
    2051
    -      void_valid = isJust (tcUnifyTy main_res_ty void_ty)
    
    2052
    -      exit_code_valid = isJust (tcUnifyTy main_res_ty exit_code_ty)
    
    2053
    -
    
    2054
    -  setSrcSpan (getSrcSpan main_name) $
    
    2055
    -    if meaningful_main
    
    2056
    -    then checkTc
    
    2057
    -           (unit_valid || void_valid || exit_code_valid)
    
    2058
    -           (TcRnInvalidMainReturn main_name main_res_ty)
    
    2059
    -    else diagnosticTc
    
    2060
    -           (not (unit_valid || void_valid))
    
    2061
    -           (TcRnAmbiguousMainReturn main_name main_res_ty)
    
    2062
    -
    
    2063 2045
       let main_action = mkHsDictLet ev_binds main_expr
    
    2064
    -
    
    2065
    -  if not meaningful_main || unit_valid || void_valid
    
    2046
    +  main_res_ty <- liftZonkM $ zonkTcType res_ty
    
    2047
    +  if isJust (tcUnifyTy main_res_ty unitTy)
    
    2066 2048
       then pure main_action
    
    2067 2049
       else do
    
    2068
    -    massertPpr exit_code_valid (ppr main_res_ty)
    
    2069
    -    bind_io_id <- tcLookupKnownOccId bindIOIdOcc
    
    2070
    -    exit_with_id <- tcLookupKnownOccId exitWithIdOcc
    
    2071
    -    pure $
    
    2072
    -      nlHsTyApps bind_io_id [exit_code_ty, exit_code_ty]
    
    2073
    -        [ main_action, nlHsTyApp exit_with_id [exit_code_ty] ]
    
    2050
    +    meaningful_main <- xoptM LangExt.MeaningfulMainReturn
    
    2051
    +    void_ty <- mkTyConTy <$> tcLookupKnownOccTyCon voidTyConOcc
    
    2052
    +    exit_code_ty <- mkTyConTy <$> tcLookupKnownOccTyCon exitCodeTyConOcc
    
    2053
    +
    
    2054
    +    let void_valid = isJust (tcUnifyTy main_res_ty void_ty)
    
    2055
    +        exit_code_valid = isJust (tcUnifyTy main_res_ty exit_code_ty)
    
    2056
    +
    
    2057
    +    setSrcSpan (getSrcSpan main_name) $
    
    2058
    +      if meaningful_main
    
    2059
    +      then checkTc
    
    2060
    +             (void_valid || exit_code_valid)
    
    2061
    +             (TcRnInvalidMainReturn main_name main_res_ty)
    
    2062
    +      else diagnosticTc
    
    2063
    +             (not void_valid)
    
    2064
    +             (TcRnAmbiguousMainReturn main_name main_res_ty)
    
    2065
    +
    
    2066
    +    if not meaningful_main || void_valid
    
    2067
    +    then pure main_action
    
    2068
    +    else do
    
    2069
    +      massertPpr exit_code_valid (ppr main_res_ty)
    
    2070
    +      bind_io_id <- tcLookupKnownOccId bindIOIdOcc
    
    2071
    +      exit_with_id <- tcLookupKnownOccId exitWithIdOcc
    
    2072
    +      pure $
    
    2073
    +        nlHsTyApps bind_io_id [exit_code_ty, exit_code_ty]
    
    2074
    +          [ main_action, nlHsTyApp exit_with_id [exit_code_ty] ]
    
    2074 2075
     
    
    2075 2076
     getIOType :: TcM (TcType, TcType)
    
    2076 2077
     -- Return (IO alpha, alpha) for fresh alpha