From 74563c17c13b5559936711456c3febc788c36ddb Mon Sep 17 00:00:00 2001
From: peter klausler <pklausler@nvidia.com>
Date: Wed, 12 Sep 2018 16:27:51 -0700
Subject: [PATCH] [flang] Add "explicit" to constructors, define
 Type<TypeCategory::Derived>

Original-commit: flang-compiler/f18@79c165af65a0357f5bf90995f862fdb4ec11364e
Reviewed-on: https://github.com/flang-compiler/f18/pull/183
Tree-same-pre-rewrite: false
---
 flang/lib/evaluate/CMakeLists.txt | 36 ++++++---------
 flang/lib/evaluate/expression.cc  |  8 ++--
 flang/lib/evaluate/expression.h   | 90 +++++++++++++++++++++++--------------
 flang/lib/evaluate/tools.cc       | 93 +++++++++++++++++++++------------------
 flang/lib/evaluate/tools.h        | 48 ++++++++++----------
 flang/lib/evaluate/type.cc        | 25 +++++++++++
 flang/lib/evaluate/type.h         | 58 +++++++++++++++++++-----
 flang/lib/evaluate/variable.cc    |  7 +--
 flang/lib/semantics/expression.cc |  3 +-
 9 files changed, 229 insertions(+), 139 deletions(-)
 create mode 100644 flang/lib/evaluate/type.cc

diff --git a/flang/lib/evaluate/CMakeLists.txt b/flang/lib/evaluate/CMakeLists.txt
index 33fd65c..163e57a 100644
--- a/flang/lib/evaluate/CMakeLists.txt
+++ b/flang/lib/evaluate/CMakeLists.txt
@@ -1,28 +1,18 @@
-# Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
+#Copyright(c) 2018, NVIDIA CORPORATION.All rights reserved.
 #
-# 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
+#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
+#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.
+#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.
 
-add_library(FortranEvaluate
-  common.cc
-  complex.cc
-  expression.cc
-  integer.cc
-  logical.cc
-  real.cc
-  tools.cc
-  variable.cc
-)
+add_library(FortranEvaluate common.cc complex.cc expression.cc integer
+                .cc logical.cc real.cc tools.cc type.cc variable.cc)
 
-target_link_libraries(FortranEvaluate
-  FortranCommon
-)
+    target_link_libraries(FortranEvaluate FortranCommon)
diff --git a/flang/lib/evaluate/expression.cc b/flang/lib/evaluate/expression.cc
index 1f2deca..1904daf 100644
--- a/flang/lib/evaluate/expression.cc
+++ b/flang/lib/evaluate/expression.cc
@@ -76,14 +76,14 @@ auto ExpressionBase<RESULT>::Fold(FoldingContext &context)
                 // Folding may have produced a constant of some
                 // dissimilar LOGICAL kind.
                 bool truth{c->value.IsTrue()};
-                derived() = truth;
+                derived() = Derived{truth};
                 return {Const{truth}};
               }
               if constexpr (std::is_same_v<Parentheses<Result>, Thing>) {
                 // Preserve parentheses around constants.
-                derived() = Thing{Derived{*c}};
+                derived() = Derived{Thing{Derived{*c}}};
               } else {
-                derived() = *c;
+                derived() = Derived{*c};
               }
               return {Const{c->value}};
             }
@@ -519,6 +519,8 @@ auto ExpressionBase<RESULT>::ScalarValue() const
             [](const BOZLiteralConstant &) -> std::optional<Scalar<Result>> {
               return std::nullopt;
             },
+            [](const Expr<Type<TypeCategory::Derived>> &)
+                -> std::optional<Scalar<Result>> { return std::nullopt; },
             [](const auto &catEx) -> std::optional<Scalar<Result>> {
               if (auto cv{catEx.ScalarValue()}) {
                 // *cv is SomeKindScalar<CAT> for some category; rewrap it.
diff --git a/flang/lib/evaluate/expression.h b/flang/lib/evaluate/expression.h
index 30cc75b..339e825 100644
--- a/flang/lib/evaluate/expression.h
+++ b/flang/lib/evaluate/expression.h
@@ -121,8 +121,8 @@ private:
 
 public:
   CLASS_BOILERPLATE(Operation)
-  Operation(const Expr<OPERANDS> &... x) : operand_{x...} {}
-  Operation(Expr<OPERANDS> &&... x)
+  explicit Operation(const Expr<OPERANDS> &... x) : operand_{x...} {}
+  explicit Operation(Expr<OPERANDS> &&... x)
     : operand_{std::forward<Expr<OPERANDS>>(x)...} {}
 
   Derived &derived() { return *static_cast<Derived *>(this); }
@@ -431,13 +431,14 @@ public:
   // TODO: R916 type-param-inquiry
 
   CLASS_BOILERPLATE(Expr)
-  Expr(const Scalar<Result> &x) : u{Constant<Result>{x}} {}
-  Expr(std::int64_t n) : u{Constant<Result>{n}} {}
-  Expr(std::uint64_t n) : u{Constant<Result>{n}} {}
-  Expr(int n) : u{Constant<Result>{n}} {}
-  template<typename A> Expr(const A &x) : u{x} {}
+  explicit Expr(const Scalar<Result> &x) : u{Constant<Result>{x}} {}
+  explicit Expr(std::int64_t n) : u{Constant<Result>{n}} {}
+  explicit Expr(std::uint64_t n) : u{Constant<Result>{n}} {}
+  explicit Expr(int n) : u{Constant<Result>{n}} {}
+  template<typename A> explicit Expr(const A &x) : u{x} {}
   template<typename A>
-  Expr(std::enable_if_t<!std::is_reference_v<A>, A> &&x) : u(std::move(x)) {}
+  explicit Expr(std::enable_if_t<!std::is_reference_v<A>, A> &&x)
+    : u(std::move(x)) {}
 
 private:
   using Conversions = std::variant<Convert<Result, TypeCategory::Integer>,
@@ -460,10 +461,11 @@ public:
   using IsFoldableTrait = std::true_type;
 
   CLASS_BOILERPLATE(Expr)
-  Expr(const Scalar<Result> &x) : u{Constant<Result>{x}} {}
-  template<typename A> Expr(const A &x) : u{x} {}
+  explicit Expr(const Scalar<Result> &x) : u{Constant<Result>{x}} {}
+  template<typename A> explicit Expr(const A &x) : u{x} {}
   template<typename A>
-  Expr(std::enable_if_t<!std::is_reference_v<A>, A> &&x) : u{std::move(x)} {}
+  explicit Expr(std::enable_if_t<!std::is_reference_v<A>, A> &&x)
+    : u{std::move(x)} {}
 
 private:
   // N.B. Real->Complex and Complex->Real conversions are done with CMPLX
@@ -488,10 +490,11 @@ public:
   using Result = Type<TypeCategory::Complex, KIND>;
   using IsFoldableTrait = std::true_type;
   CLASS_BOILERPLATE(Expr)
-  Expr(const Scalar<Result> &x) : u{Constant<Result>{x}} {}
-  template<typename A> Expr(const A &x) : u{x} {}
+  explicit Expr(const Scalar<Result> &x) : u{Constant<Result>{x}} {}
+  template<typename A> explicit Expr(const A &x) : u{x} {}
   template<typename A>
-  Expr(std::enable_if_t<!std::is_reference_v<A>, A> &&x) : u{std::move(x)} {}
+  explicit Expr(std::enable_if_t<!std::is_reference_v<A>, A> &&x)
+    : u{std::move(x)} {}
 
   // Note that many COMPLEX operations are represented as REAL operations
   // over their components (viz., conversions, negation, add, and subtract).
@@ -528,12 +531,14 @@ public:
   using Result = Type<TypeCategory::Character, KIND>;
   using IsFoldableTrait = std::true_type;
   CLASS_BOILERPLATE(Expr)
-  Expr(const Scalar<Result> &x) : u{Constant<Result>{x}} {}
-  Expr(Scalar<Result> &&x) : u{Constant<Result>{std::move(x)}} {}
-  template<typename A> Expr(const A &x) : u{x} {}
+  explicit Expr(const Scalar<Result> &x) : u{Constant<Result>{x}} {}
+  explicit Expr(Scalar<Result> &&x) : u{Constant<Result>{std::move(x)}} {}
+  template<typename A> explicit Expr(const A &x) : u{x} {}
+  template<typename A>
+  explicit Expr(std::enable_if_t<!std::is_reference_v<A>, A> &&x)
+    : u{std::move(x)} {}
   template<typename A>
-  Expr(std::enable_if_t<!std::is_reference_v<A>, A> &&x) : u{std::move(x)} {}
-  template<typename A> Expr(CopyableIndirection<A> &&x) : u{std::move(x)} {}
+  explicit Expr(CopyableIndirection<A> &&x) : u{std::move(x)} {}
 
   Expr<SubscriptInteger> LEN() const;
 
@@ -583,9 +588,9 @@ template<> class Relational<SomeType> {
 public:
   using Result = LogicalResult;
   CLASS_BOILERPLATE(Relational)
-  template<typename A> Relational(const A &x) : u(x) {}
+  template<typename A> explicit Relational(const A &x) : u(x) {}
   template<typename A>
-  Relational(std::enable_if_t<!std::is_reference_v<A>, A> &&x)
+  explicit Relational(std::enable_if_t<!std::is_reference_v<A>, A> &&x)
     : u{std::move(x)} {}
   std::ostream &Dump(std::ostream &o) const;
   common::MapTemplate<Relational, DirectlyComparableTypes> u;
@@ -613,11 +618,12 @@ public:
   using Result = Type<TypeCategory::Logical, KIND>;
   using IsFoldableTrait = std::true_type;
   CLASS_BOILERPLATE(Expr)
-  Expr(const Scalar<Result> &x) : u{Constant<Result>{x}} {}
-  Expr(bool x) : u{Constant<Result>{x}} {}
-  template<typename A> Expr(const A &x) : u(x) {}
+  explicit Expr(const Scalar<Result> &x) : u{Constant<Result>{x}} {}
+  explicit Expr(bool x) : u{Constant<Result>{x}} {}
+  template<typename A> explicit Expr(const A &x) : u(x) {}
   template<typename A>
-  Expr(std::enable_if_t<!std::is_reference_v<A>, A> &&x) : u{std::move(x)} {}
+  explicit Expr(std::enable_if_t<!std::is_reference_v<A>, A> &&x)
+    : u{std::move(x)} {}
 
 private:
   using Operations = std::variant<Convert<Result, TypeCategory::Logical>,
@@ -634,6 +640,22 @@ extern template class Expr<Type<TypeCategory::Logical, 2>>;
 extern template class Expr<Type<TypeCategory::Logical, 4>>;
 extern template class Expr<Type<TypeCategory::Logical, 8>>;
 
+template<>
+class Expr<Type<TypeCategory::Derived>>
+  : public ExpressionBase<Type<TypeCategory::Derived>> {
+public:
+  using Result = Type<TypeCategory::Derived>;
+  using IsFoldableTrait = std::false_type;
+  CLASS_BOILERPLATE(Expr)
+  template<typename A>
+  explicit Expr(const Result &r, const A &x) : result{r}, u{x} {}
+  template<typename A>
+  explicit Expr(Result &&r, std::enable_if_t<!std::is_reference_v<A>, A> &&x)
+    : result{std::move(r)}, u{std::move(x)} {}
+  Result result;
+  std::variant<DataReference<Result>, FunctionReference<Result>> u;
+};
+
 // A polymorphic expression of known intrinsic type category, but dynamic
 // kind, represented as a discriminated union over Expr<Type<CAT, K>>
 // for each supported kind K in the category.
@@ -644,9 +666,10 @@ public:
   using IsFoldableTrait = std::true_type;
   CLASS_BOILERPLATE(Expr)
 
-  template<typename A> Expr(const A &x) : u{x} {}
+  template<typename A> explicit Expr(const A &x) : u{x} {}
   template<typename A>
-  Expr(std::enable_if_t<!std::is_reference_v<A>, A> &&x) : u{std::move(x)} {}
+  explicit Expr(std::enable_if_t<!std::is_reference_v<A>, A> &&x)
+    : u{std::move(x)} {}
 
   common::MapTemplate<Expr, CategoryTypes<CAT>> u;
 };
@@ -664,15 +687,17 @@ public:
   // its destructor is externalized to reduce redundant default instances.
   ~Expr();
 
-  template<typename A> Expr(const A &x) : u{x} {}
+  template<typename A> explicit Expr(const A &x) : u{x} {}
   template<typename A>
-  Expr(std::enable_if_t<!std::is_reference_v<A>, A> &&x) : u{std::move(x)} {}
+  explicit Expr(std::enable_if_t<!std::is_reference_v<A>, A> &&x)
+    : u{std::move(x)} {}
 
   template<TypeCategory CAT, int KIND>
-  Expr(const Expr<Type<CAT, KIND>> &x) : u{Expr<SomeKind<CAT>>{x}} {}
+  explicit Expr(const Expr<Type<CAT, KIND>> &x) : u{Expr<SomeKind<CAT>>{x}} {}
 
   template<TypeCategory CAT, int KIND>
-  Expr(Expr<Type<CAT, KIND>> &&x) : u{Expr<SomeKind<CAT>>{std::move(x)}} {}
+  explicit Expr(Expr<Type<CAT, KIND>> &&x)
+    : u{Expr<SomeKind<CAT>>{std::move(x)}} {}
 
   template<TypeCategory CAT, int KIND>
   Expr &operator=(const Expr<Type<CAT, KIND>> &x) {
@@ -686,7 +711,8 @@ public:
     return *this;
   }
 
-  using Others = std::variant<BOZLiteralConstant>;
+  using Others =
+      std::variant<BOZLiteralConstant, Expr<Type<TypeCategory::Derived>>>;
   using Categories = common::MapTemplate<Expr, SomeCategory>;
   common::CombineVariants<Others, Categories> u;
 };
diff --git a/flang/lib/evaluate/tools.cc b/flang/lib/evaluate/tools.cc
index fb85185..45fdb74 100644
--- a/flang/lib/evaluate/tools.cc
+++ b/flang/lib/evaluate/tools.cc
@@ -27,14 +27,15 @@ ConvertRealOperandsResult ConvertRealOperands(
     parser::ContextualMessages &messages, Expr<SomeType> &&x,
     Expr<SomeType> &&y) {
   return std::visit(
-      common::visitors{[&](Expr<SomeInteger> &&ix, Expr<SomeInteger> &&iy)
-                           -> ConvertRealOperandsResult {
-                         // Can happen in a CMPLX() constructor.  Per F'2018,
-                         // both integer operands are converted to default REAL.
-                         return {AsSameKindExprs<TypeCategory::Real>(
-                             ConvertToType<DefaultReal>(std::move(ix)),
-                             ConvertToType<DefaultReal>(std::move(iy)))};
-                       },
+      common::visitors{
+          [&](Expr<SomeInteger> &&ix,
+              Expr<SomeInteger> &&iy) -> ConvertRealOperandsResult {
+            // Can happen in a CMPLX() constructor.  Per F'2018,
+            // both integer operands are converted to default REAL.
+            return {AsSameKindExprs<TypeCategory::Real>(
+                AsCategoryExpr(ConvertToType<DefaultReal>(std::move(ix))),
+                AsCategoryExpr(ConvertToType<DefaultReal>(std::move(iy))))};
+          },
           [&](Expr<SomeInteger> &&ix,
               Expr<SomeReal> &&ry) -> ConvertRealOperandsResult {
             return {AsSameKindExprs<TypeCategory::Real>(
@@ -53,14 +54,14 @@ ConvertRealOperandsResult ConvertRealOperands(
           [&](Expr<SomeInteger> &&ix,
               BOZLiteralConstant &&by) -> ConvertRealOperandsResult {
             return {AsSameKindExprs<TypeCategory::Real>(
-                ConvertToType<DefaultReal>(std::move(ix)),
-                ConvertToType<DefaultReal>(std::move(by)))};
+                AsCategoryExpr(ConvertToType<DefaultReal>(std::move(ix))),
+                AsCategoryExpr(ConvertToType<DefaultReal>(std::move(by))))};
           },
           [&](BOZLiteralConstant &&bx,
               Expr<SomeInteger> &&iy) -> ConvertRealOperandsResult {
             return {AsSameKindExprs<TypeCategory::Real>(
-                ConvertToType<DefaultReal>(std::move(bx)),
-                ConvertToType<DefaultReal>(std::move(iy)))};
+                AsCategoryExpr(ConvertToType<DefaultReal>(std::move(bx))),
+                AsCategoryExpr(ConvertToType<DefaultReal>(std::move(iy))))};
           },
           [&](Expr<SomeReal> &&rx,
               BOZLiteralConstant &&by) -> ConvertRealOperandsResult {
@@ -285,20 +286,20 @@ std::optional<Expr<SomeType>> NumericOperation(
           },
           // Operations with one typeless operand
           [&](BOZLiteralConstant &&bx, Expr<SomeInteger> &&iy) {
-            return NumericOperation<OPR>(
-                messages, ConvertTo(iy, std::move(bx)), std::move(y));
+            return NumericOperation<OPR>(messages,
+                AsGenericExpr(ConvertTo(iy, std::move(bx))), std::move(y));
           },
           [&](BOZLiteralConstant &&bx, Expr<SomeReal> &&ry) {
-            return NumericOperation<OPR>(
-                messages, ConvertTo(ry, std::move(bx)), std::move(y));
+            return NumericOperation<OPR>(messages,
+                AsGenericExpr(ConvertTo(ry, std::move(bx))), std::move(y));
           },
           [&](Expr<SomeInteger> &&ix, BOZLiteralConstant &&by) {
-            return NumericOperation<OPR>(
-                messages, std::move(x), ConvertTo(ix, std::move(by)));
+            return NumericOperation<OPR>(messages, std::move(x),
+                AsGenericExpr(ConvertTo(ix, std::move(by))));
           },
           [&](Expr<SomeReal> &&rx, BOZLiteralConstant &&by) {
-            return NumericOperation<OPR>(
-                messages, std::move(x), ConvertTo(rx, std::move(by)));
+            return NumericOperation<OPR>(messages, std::move(x),
+                AsGenericExpr(ConvertTo(rx, std::move(by))));
           },
           // Default case
           [&](auto &&, auto &&) {
@@ -323,11 +324,11 @@ template std::optional<Expr<SomeType>> NumericOperation<Subtract>(
 std::optional<Expr<SomeType>> Negation(
     parser::ContextualMessages &messages, Expr<SomeType> &&x) {
   return std::visit(
-      common::visitors{[&](BOZLiteralConstant &&) {
-                         messages.Say(
-                             "BOZ literal cannot be negated"_err_en_US);
-                         return NoExpr();
-                       },
+      common::visitors{
+          [&](BOZLiteralConstant &&) {
+            messages.Say("BOZ literal cannot be negated"_err_en_US);
+            return NoExpr();
+          },
           [&](Expr<SomeInteger> &&x) { return Package(std::move(x)); },
           [&](Expr<SomeReal> &&x) { return Package(-std::move(x)); },
           [&](Expr<SomeComplex> &&x) { return Package(-std::move(x)); },
@@ -340,7 +341,13 @@ std::optional<Expr<SomeType>> Negation(
             // TODO: defined operator
             messages.Say("LOGICAL cannot be negated"_err_en_US);
             return NoExpr();
-          }},
+          },
+          [&](Expr<Type<TypeCategory::Derived>> &&x) {
+            // TODO: defined operator
+            messages.Say("derived type cannot be negated"_err_en_US);
+            return NoExpr();
+          },
+      },
       std::move(x.u));
 }
 
@@ -383,12 +390,12 @@ std::optional<Expr<LogicalResult>> Relate(parser::ContextualMessages &messages,
                 PromoteAndRelate(opr, std::move(rx), std::move(ry)));
           },
           [&](Expr<SomeReal> &&rx, Expr<SomeInteger> &&iy) {
-            return Relate(
-                messages, opr, std::move(x), ConvertTo(rx, std::move(iy)));
+            return Relate(messages, opr, std::move(x),
+                AsGenericExpr(ConvertTo(rx, std::move(iy))));
           },
           [&](Expr<SomeInteger> &&ix, Expr<SomeReal> &&ry) {
-            return Relate(
-                messages, opr, ConvertTo(ry, std::move(ix)), std::move(y));
+            return Relate(messages, opr,
+                AsGenericExpr(ConvertTo(ry, std::move(ix))), std::move(y));
           },
           [&](Expr<SomeComplex> &&zx, Expr<SomeComplex> &&zy) {
             if (opr != RelationalOperator::EQ &&
@@ -397,10 +404,12 @@ std::optional<Expr<LogicalResult>> Relate(parser::ContextualMessages &messages,
                   "COMPLEX data may be compared only for equality"_err_en_US);
               return std::optional<Expr<LogicalResult>>{};
             } else {
-              auto rr{Relate(messages, opr, GetComplexPart(zx, false),
-                  GetComplexPart(zy, false))};
-              auto ri{Relate(messages, opr, GetComplexPart(zx, true),
-                  GetComplexPart(zy, true))};
+              auto rr{Relate(messages, opr,
+                  AsGenericExpr(GetComplexPart(zx, false)),
+                  AsGenericExpr(GetComplexPart(zy, false)))};
+              auto ri{
+                  Relate(messages, opr, AsGenericExpr(GetComplexPart(zx, true)),
+                      AsGenericExpr(GetComplexPart(zy, true)))};
               if (auto parts{
                       common::AllPresent(std::move(rr), std::move(ri))}) {
                 // (a,b)==(c,d) -> (a==c) .AND. (b==d)
@@ -418,20 +427,20 @@ std::optional<Expr<LogicalResult>> Relate(parser::ContextualMessages &messages,
             }
           },
           [&](Expr<SomeComplex> &&zx, Expr<SomeInteger> &&iy) {
-            return Relate(
-                messages, opr, std::move(x), ConvertTo(zx, std::move(iy)));
+            return Relate(messages, opr, std::move(x),
+                AsGenericExpr(ConvertTo(zx, std::move(iy))));
           },
           [&](Expr<SomeComplex> &&zx, Expr<SomeReal> &&ry) {
-            return Relate(
-                messages, opr, std::move(x), ConvertTo(zx, std::move(ry)));
+            return Relate(messages, opr, std::move(x),
+                AsGenericExpr(ConvertTo(zx, std::move(ry))));
           },
           [&](Expr<SomeInteger> &&ix, Expr<SomeComplex> &&zy) {
-            return Relate(
-                messages, opr, ConvertTo(zy, std::move(ix)), std::move(y));
+            return Relate(messages, opr,
+                AsGenericExpr(ConvertTo(zy, std::move(ix))), std::move(y));
           },
           [&](Expr<SomeReal> &&rx, Expr<SomeComplex> &&zy) {
-            return Relate(
-                messages, opr, ConvertTo(zy, std::move(rx)), std::move(y));
+            return Relate(messages, opr,
+                AsGenericExpr(ConvertTo(zy, std::move(rx))), std::move(y));
           },
           [&](Expr<SomeCharacter> &&cx, Expr<SomeCharacter> &&cy) {
             return std::visit(
diff --git a/flang/lib/evaluate/tools.h b/flang/lib/evaluate/tools.h
index fa331bf..afab368 100644
--- a/flang/lib/evaluate/tools.h
+++ b/flang/lib/evaluate/tools.h
@@ -28,12 +28,12 @@ namespace Fortran::evaluate {
 // specific types and wrap them in Expr<> containers of more abstract types.
 
 template<typename A> Expr<ResultType<A>> AsExpr(A &&x) {
-  return {std::move(x)};
+  return Expr<ResultType<A>>{std::move(x)};
 }
 
 template<TypeCategory CAT, int KIND>
 Expr<SomeKind<CAT>> AsCategoryExpr(Expr<Type<CAT, KIND>> &&x) {
-  return {std::move(x)};
+  return Expr<SomeKind<CAT>>{std::move(x)};
 }
 
 template<TypeCategory CAT>
@@ -47,12 +47,12 @@ Expr<SomeKind<CAT>> AsCategoryExpr(SomeKindScalar<CAT> &&x) {
 }
 
 template<typename A> Expr<SomeType> AsGenericExpr(A &&x) {
-  return {std::move(x)};
+  return Expr<SomeType>{std::move(x)};
 }
 
 template<TypeCategory CAT, int KIND>
 Expr<SomeType> AsGenericExpr(Expr<Type<CAT, KIND>> &&x) {
-  return {AsCategoryExpr(std::move(x))};
+  return Expr<SomeType>{AsCategoryExpr(std::move(x))};
 }
 
 template<> inline Expr<SomeType> AsGenericExpr(Constant<SomeType> &&x) {
@@ -96,10 +96,10 @@ Expr<TO> ConvertToType(Expr<SomeKind<FROMCAT>> &&x) {
     if constexpr (TO::category == TypeCategory::Complex) {
       using Part = typename TO::Part;
       Scalar<Part> zero;
-      return {ComplexConstructor<TO::kind>{
+      return Expr<TO>{ComplexConstructor<TO::kind>{
           ConvertToType<Part>(std::move(x)), Expr<Part>{Constant<Part>{zero}}}};
     } else {
-      return {Convert<TO, FROMCAT>{std::move(x)}};
+      return Expr<TO>{Convert<TO, FROMCAT>{std::move(x)}};
     }
   } else {
     // Same type category
@@ -108,8 +108,8 @@ Expr<TO> ConvertToType(Expr<SomeKind<FROMCAT>> &&x) {
     }
     if constexpr (TO::category == TypeCategory::Complex) {
       // Extract, convert, and recombine the components.
-      return {std::visit(
-          [](auto &z) -> ComplexConstructor<TO::kind> {
+      return Expr<TO>{std::visit(
+          [](auto &z) {
             using FromType = ResultType<decltype(z)>;
             using FromPart = typename FromType::Part;
             using FromGeneric = SomeKind<TypeCategory::Real>;
@@ -118,11 +118,12 @@ Expr<TO> ConvertToType(Expr<SomeKind<FROMCAT>> &&x) {
                 Expr<FromPart>{ComplexComponent<FromType::kind>{false, z}}}};
             Convert<ToPart, TypeCategory::Real> im{Expr<FromGeneric>{
                 Expr<FromPart>{ComplexComponent<FromType::kind>{true, z}}}};
-            return {std::move(re), std::move(im)};
+            return ComplexConstructor<TO::kind>{
+                AsExpr(std::move(re)), AsExpr(std::move(im))};
           },
           x.u)};
     } else {
-      return {Convert<TO, TO::category>{std::move(x)}};
+      return Expr<TO>{Convert<TO, TO::category>{std::move(x)}};
     }
   }
 }
@@ -148,7 +149,7 @@ Expr<Type<TC, TK>> ConvertTo(
 template<TypeCategory TC, int TK, TypeCategory FC, int FK>
 Expr<Type<TC, TK>> ConvertTo(
     const Expr<Type<TC, TK>> &, Expr<Type<FC, FK>> &&x) {
-  return ConvertToType<Type<TC, TK>>(AsCategoryExpr(std::move(x)));
+  return AsExpr(ConvertToType<Type<TC, TK>>(AsCategoryExpr(std::move(x))));
 }
 
 template<TypeCategory TC, TypeCategory FC>
@@ -264,11 +265,11 @@ Expr<SPECIFIC> Combine(Expr<SPECIFIC> &&x, Expr<SPECIFIC> &&y) {
           std::is_same_v<OPR<DefaultReal>, Subtract<DefaultReal>>)) {
     static constexpr int kind{SPECIFIC::kind};
     using Part = Type<TypeCategory::Real, kind>;
-    return AsExpr(
-        ComplexConstructor<kind>{OPR<Part>{ComplexComponent<kind>{false, x},
-                                     ComplexComponent<kind>{false, y}},
-            OPR<Part>{ComplexComponent<kind>{true, x},
-                ComplexComponent<kind>{true, y}}});
+    return AsExpr(ComplexConstructor<kind>{
+        AsExpr(OPR<Part>{AsExpr(ComplexComponent<kind>{false, x}),
+            AsExpr(ComplexComponent<kind>{false, y})}),
+        AsExpr(OPR<Part>{AsExpr(ComplexComponent<kind>{true, x}),
+            AsExpr(ComplexComponent<kind>{true, y})})});
   } else {
     return AsExpr(OPR<SPECIFIC>{std::move(x), std::move(y)});
   }
@@ -329,35 +330,36 @@ Expr<SomeLogical> BinaryLogicalOperation(
 
 template<TypeCategory C, int K>
 Expr<Type<C, K>> operator-(Expr<Type<C, K>> &&x) {
-  return {Negate<Type<C, K>>{std::move(x)}};
+  return AsExpr(Negate<Type<C, K>>{std::move(x)});
 }
 
 template<int K>
 Expr<Type<TypeCategory::Complex, K>> operator-(
     Expr<Type<TypeCategory::Complex, K>> &&x) {
   using Part = Type<TypeCategory::Real, K>;
-  return {ComplexConstructor<K>{Negate<Part>{ComplexComponent<K>{false, x}},
-      Negate<Part>{ComplexComponent<K>{true, x}}}};
+  return AsExpr(ComplexConstructor<K>{
+      AsExpr(Negate<Part>{AsExpr(ComplexComponent<K>{false, x})}),
+      AsExpr(Negate<Part>{AsExpr(ComplexComponent<K>{true, x})})});
 }
 
 template<TypeCategory C, int K>
 Expr<Type<C, K>> operator+(Expr<Type<C, K>> &&x, Expr<Type<C, K>> &&y) {
-  return {Combine<Add, Type<C, K>>(std::move(x), std::move(y))};
+  return AsExpr(Combine<Add, Type<C, K>>(std::move(x), std::move(y)));
 }
 
 template<TypeCategory C, int K>
 Expr<Type<C, K>> operator-(Expr<Type<C, K>> &&x, Expr<Type<C, K>> &&y) {
-  return {Combine<Subtract, Type<C, K>>(std::move(x), std::move(y))};
+  return AsExpr(Combine<Subtract, Type<C, K>>(std::move(x), std::move(y)));
 }
 
 template<TypeCategory C, int K>
 Expr<Type<C, K>> operator*(Expr<Type<C, K>> &&x, Expr<Type<C, K>> &&y) {
-  return {Combine<Multiply, Type<C, K>>(std::move(x), std::move(y))};
+  return AsExpr(Combine<Multiply, Type<C, K>>(std::move(x), std::move(y)));
 }
 
 template<TypeCategory C, int K>
 Expr<Type<C, K>> operator/(Expr<Type<C, K>> &&x, Expr<Type<C, K>> &&y) {
-  return {Combine<Divide, Type<C, K>>(std::move(x), std::move(y))};
+  return AsExpr(Combine<Divide, Type<C, K>>(std::move(x), std::move(y)));
 }
 
 template<TypeCategory C> Expr<SomeKind<C>> operator-(Expr<SomeKind<C>> &&x) {
diff --git a/flang/lib/evaluate/type.cc b/flang/lib/evaluate/type.cc
new file mode 100644
index 0000000..2ee4db5a
--- /dev/null
+++ b/flang/lib/evaluate/type.cc
@@ -0,0 +1,25 @@
+// Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
+//
+// 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.
+
+#include "type.h"
+#include "../semantics/type.h"
+#include <string>
+
+using namespace std::literals::string_literals;
+
+namespace Fortran::evaluate {
+std::string Type<TypeCategory::Derived>::Dump() const {
+  return "TYPE("s + spec().name().ToString() + ')';
+}
+}  // namespace Fortran::evaluate
diff --git a/flang/lib/evaluate/type.h b/flang/lib/evaluate/type.h
index 889c897..746c39e 100644
--- a/flang/lib/evaluate/type.h
+++ b/flang/lib/evaluate/type.h
@@ -22,6 +22,7 @@
 // are suitable for use as template parameters to instantiate other class
 // templates, like expressions, over the supported types and kinds.
 
+#include "common.h"
 #include "complex.h"
 #include "integer.h"
 #include "logical.h"
@@ -34,13 +35,17 @@
 #include <string>
 #include <variant>
 
+namespace Fortran::semantics {
+class DerivedTypeSpec;
+}  // namespace Fortran::semantics
+
 namespace Fortran::evaluate {
 
 using common::TypeCategory;
 
 // Specific intrinsic types are represented by specializations of
 // this class template Type<CATEGORY, KIND>.
-template<TypeCategory CATEGORY, int KIND> struct Type;
+template<TypeCategory CATEGORY, int KIND = 0> class Type;
 
 template<TypeCategory CATEGORY, int KIND> struct TypeBase {
   static constexpr bool isSpecificType{true};
@@ -52,71 +57,100 @@ template<TypeCategory CATEGORY, int KIND> struct TypeBase {
 };
 
 template<int KIND>
-struct Type<TypeCategory::Integer, KIND>
+class Type<TypeCategory::Integer, KIND>
   : public TypeBase<TypeCategory::Integer, KIND> {
+public:
   using Scalar = value::Integer<8 * KIND>;
 };
 
 template<>
-struct Type<TypeCategory::Real, 2> : public TypeBase<TypeCategory::Real, 2> {
+class Type<TypeCategory::Real, 2> : public TypeBase<TypeCategory::Real, 2> {
+public:
   using Scalar =
       value::Real<typename Type<TypeCategory::Integer, 2>::Scalar, 11>;
 };
 
 template<>
-struct Type<TypeCategory::Real, 4> : public TypeBase<TypeCategory::Real, 4> {
+class Type<TypeCategory::Real, 4> : public TypeBase<TypeCategory::Real, 4> {
+public:
   using Scalar =
       value::Real<typename Type<TypeCategory::Integer, 4>::Scalar, 24>;
 };
 
 template<>
-struct Type<TypeCategory::Real, 8> : public TypeBase<TypeCategory::Real, 8> {
+class Type<TypeCategory::Real, 8> : public TypeBase<TypeCategory::Real, 8> {
+public:
   using Scalar =
       value::Real<typename Type<TypeCategory::Integer, 8>::Scalar, 53>;
 };
 
 template<>
-struct Type<TypeCategory::Real, 10> : public TypeBase<TypeCategory::Real, 10> {
+class Type<TypeCategory::Real, 10> : public TypeBase<TypeCategory::Real, 10> {
+public:
   using Scalar = value::Real<value::Integer<80>, 64, false>;
 };
 
 template<>
-struct Type<TypeCategory::Real, 16> : public TypeBase<TypeCategory::Real, 16> {
+class Type<TypeCategory::Real, 16> : public TypeBase<TypeCategory::Real, 16> {
+public:
   using Scalar = value::Real<value::Integer<128>, 112>;
 };
 
 // The KIND type parameter on COMPLEX is the kind of each of its components.
 template<int KIND>
-struct Type<TypeCategory::Complex, KIND>
+class Type<TypeCategory::Complex, KIND>
   : public TypeBase<TypeCategory::Complex, KIND> {
+public:
   using Part = Type<TypeCategory::Real, KIND>;
   using Scalar = value::Complex<typename Part::Scalar>;
 };
 
 template<>
-struct Type<TypeCategory::Character, 1>
+class Type<TypeCategory::Character, 1>
   : public TypeBase<TypeCategory::Character, 1> {
+public:
   using Scalar = std::string;
 };
 
 template<>
-struct Type<TypeCategory::Character, 2>
+class Type<TypeCategory::Character, 2>
   : public TypeBase<TypeCategory::Character, 2> {
+public:
   using Scalar = std::u16string;
 };
 
 template<>
-struct Type<TypeCategory::Character, 4>
+class Type<TypeCategory::Character, 4>
   : public TypeBase<TypeCategory::Character, 4> {
+public:
   using Scalar = std::u32string;
 };
 
 template<int KIND>
-struct Type<TypeCategory::Logical, KIND>
+class Type<TypeCategory::Logical, KIND>
   : public TypeBase<TypeCategory::Logical, KIND> {
+public:
   using Scalar = value::Logical<8 * KIND>;
 };
 
+template<> class Type<TypeCategory::Derived> {
+public:
+  static constexpr bool isSpecificType{true};
+  static constexpr TypeCategory category{TypeCategory::Derived};
+  using Scalar = void;
+
+  CLASS_BOILERPLATE(Type)
+  explicit Type(const semantics::DerivedTypeSpec &s) : spec_{&s} {}
+
+  const semantics::DerivedTypeSpec &spec() const { return *spec_; }
+  std::string Dump() const;
+
+private:
+  // This member should be a reference, except that copy construction
+  // and assignment would not be possible.
+  const semantics::DerivedTypeSpec *spec_;
+};
+
 // Type functions
 
 template<typename T> using Scalar = typename std::decay_t<T>::Scalar;
diff --git a/flang/lib/evaluate/variable.cc b/flang/lib/evaluate/variable.cc
index ccd51e8..81cf416 100644
--- a/flang/lib/evaluate/variable.cc
+++ b/flang/lib/evaluate/variable.cc
@@ -107,7 +107,7 @@ Expr<SubscriptInteger> Substring::first() const {
   if (first_.has_value()) {
     return **first_;
   }
-  return {1};
+  return AsExpr(Constant<SubscriptInteger>{1});
 }
 
 Expr<SubscriptInteger> Substring::last() const {
@@ -349,8 +349,9 @@ Expr<SubscriptInteger> DataRef::LEN() const {
       u_);
 }
 Expr<SubscriptInteger> Substring::LEN() const {
-  return Extremum<SubscriptInteger>{AsExpr(Constant<SubscriptInteger>{0}),
-      last() - first() + AsExpr(Constant<SubscriptInteger>{1})};
+  return AsExpr(
+      Extremum<SubscriptInteger>{AsExpr(Constant<SubscriptInteger>{0}),
+          last() - first() + AsExpr(Constant<SubscriptInteger>{1})});
 }
 Expr<SubscriptInteger> ProcedureDesignator::LEN() const {
   return std::visit(
diff --git a/flang/lib/semantics/expression.cc b/flang/lib/semantics/expression.cc
index b0800a3..adbb24b 100644
--- a/flang/lib/semantics/expression.cc
+++ b/flang/lib/semantics/expression.cc
@@ -595,6 +595,7 @@ MaybeExpr ExprAnalyzer::Analyze(const parser::Expr::Parentheses &x) {
             [&](BOZLiteralConstant &&boz) {
               return operand;  // ignore parentheses around typeless
             },
+            [&](Expr<Type<TypeCategory::Derived>> &&dte) { return operand; },
             [](auto &&catExpr) {
               return std::visit(
                   [](auto &&expr) -> MaybeExpr {
@@ -635,7 +636,7 @@ MaybeExpr ExprAnalyzer::Analyze(const parser::Expr::UnaryPlus &x) {
 
 MaybeExpr ExprAnalyzer::Analyze(const parser::Expr::Negate &x) {
   if (MaybeExpr operand{AnalyzeHelper(*this, *x.v)}) {
-    return Negation(context.messages, std::move(operand->u));
+    return Negation(context.messages, std::move(*operand));
   }
   return std::nullopt;
 }
-- 
2.7.4