zeroc-ice 3.6.5 → 3.7.0

data/ext/ice/cpp/src/Slice/Parser.cpp

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
 //
 // This copy of Ice is licensed to you under the terms described in the
 // ICE_LICENSE file included in this distribution.
@@ -63,6 +63,72 @@ filterOrderedOptionalDataMembers(const DataMemberList& members)
     return result;
 }
 
+void
+sortOptionalParameters(ParamDeclList& params)
+{
+    //
+    // Sort optional parameters by tag.
+    //
+    class SortFn
+    {
+    public:
+        static bool compare(const ParamDeclPtr& lhs, const ParamDeclPtr& rhs)
+        {
+            return lhs->tag() < rhs->tag();
+        }
+    };
+    params.sort(SortFn::compare);
+}
+
+bool
+isMutableAfterReturnType(const TypePtr& type)
+{
+    //
+    // Returns true if the type contains data types which can be referenced by user code
+    // and mutated after a dispatch returns.
+    //
+
+    if(ClassDeclPtr::dynamicCast(type))
+    {
+        return true;
+    }
+
+    BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
+    if(builtin && (builtin->kind() == Builtin::KindObject || builtin->kind() == Builtin::KindValue))
+    {
+        return true;
+    }
+
+    if(SequencePtr::dynamicCast(type) || DictionaryPtr::dynamicCast(type))
+    {
+        return true;
+    }
+
+    StructPtr s = StructPtr::dynamicCast(type);
+    if(s)
+    {
+        return true;
+    }
+
+    return false;
+}
+
+void
+checkDeprecatedType(const UnitPtr& unit, const TypePtr& type)
+{
+    ClassDeclPtr decl = ClassDeclPtr::dynamicCast(type);
+    if(decl && !decl->isLocal() && decl->isInterface())
+    {
+        unit->warning(Deprecated, "interface by value is deprecated");
+    }
+
+    ProxyPtr proxy = ProxyPtr::dynamicCast(type);
+    if(proxy && !proxy->_class()->isInterface())
+    {
+        unit->warning(Deprecated, "proxy for a class is deprecated");
+    }
+}
+
 }
 
 namespace Slice
@@ -79,6 +145,7 @@ Unit* unit;
 Slice::DefinitionContext::DefinitionContext(int includeLevel, const StringList& metaData) :
     _includeLevel(includeLevel), _metaData(metaData), _seenDefinition(false)
 {
+    initSuppressedWarnings();
 }
 
 string
@@ -121,6 +188,7 @@ void
 Slice::DefinitionContext::setMetaData(const StringList& metaData)
 {
     _metaData = metaData;
+    initSuppressedWarnings();
 }
 
 string
@@ -143,6 +211,74 @@ Slice::DefinitionContext::getMetaData() const
     return _metaData;
 }
 
+void
+Slice::DefinitionContext::warning(WarningCategory category, const string& file, int line, const string& msg) const
+{
+    if(!suppressWarning(category))
+    {
+        emitWarning(file, line, msg);
+    }
+}
+
+void
+Slice::DefinitionContext::warning(WarningCategory category, const string& file, const string& line, const string& msg) const
+{
+    if(!suppressWarning(category))
+    {
+        emitWarning(file, line, msg);
+    }
+}
+
+bool
+Slice::DefinitionContext::suppressWarning(WarningCategory category) const
+{
+    return _suppressedWarnings.find(category) != _suppressedWarnings.end() ||
+        _suppressedWarnings.find(All) != _suppressedWarnings.end();
+}
+
+void
+Slice::DefinitionContext::initSuppressedWarnings()
+{
+    _suppressedWarnings.clear();
+    const string prefix = "suppress-warning";
+    string value = findMetaData(prefix);
+    if(value == prefix)
+    {
+        _suppressedWarnings.insert(All);
+    }
+    else if(!value.empty())
+    {
+        assert(value.length() > prefix.length());
+        if(value[prefix.length()] == ':')
+        {
+            value = value.substr(prefix.length() + 1);
+            vector<string> result;
+            IceUtilInternal::splitString(value, ",", result);
+            for(vector<string>::iterator p = result.begin(); p != result.end(); ++p)
+            {
+                string s = IceUtilInternal::trim(*p);
+                if(s == "all")
+                {
+                    _suppressedWarnings.insert(All);
+                }
+                else if(s == "deprecated")
+                {
+                    _suppressedWarnings.insert(Deprecated);
+                }
+                else if(s == "invalid-metadata")
+                {
+                    _suppressedWarnings.insert(InvalidMetaData);
+                }
+                else
+                {
+                    warning(InvalidMetaData, "", "", string("invalid category `") + s +
+                            "' in global metadata suppress-warning");
+                }
+            }
+        }
+    }
+}
+
 // ----------------------------------------------------------------------
 // SyntaxTreeBase
 // ----------------------------------------------------------------------
@@ -258,6 +394,11 @@ Slice::Builtin::typeId() const
             return "::Ice::LocalObject";
             break;
         }
+        case KindValue:
+        {
+            return "::Ice::Value";
+            break;
+        }
     }
     assert(false);
     return ""; // Keep the compiler happy.
@@ -266,7 +407,7 @@ Slice::Builtin::typeId() const
 bool
 Slice::Builtin::usesClasses() const
 {
-    return _kind == KindObject;
+    return _kind == KindObject || _kind == KindValue;
 }
 
 size_t
@@ -283,7 +424,8 @@ Slice::Builtin::minWireSize() const
         8, // KindDouble
         1, // KindString: at least one byte for an empty string.
         1, // KindObject: at least one byte (to marshal an index instead of an instance).
-        2  // KindObjectProxy: at least an empty identity for a nil proxy, that is, 2 bytes.
+        2, // KindObjectProxy: at least an empty identity for a nil proxy, that is, 2 bytes.
+        1  // KindValue: at least one byte (to marshal an index instead of an instance).
     };
 
     assert(_kind != KindLocalObject);
@@ -293,7 +435,7 @@ Slice::Builtin::minWireSize() const
 bool
 Slice::Builtin::isVariableLength() const
 {
-    return _kind == KindString || _kind == KindObject || _kind == KindObjectProxy;
+    return _kind == KindString || _kind == KindObject || _kind == KindObjectProxy || _kind == KindValue;
 }
 
 Builtin::Kind
@@ -320,7 +462,8 @@ const char* Slice::Builtin::builtinTable[] =
         "string",
         "Object",
         "Object*",
-        "LocalObject"
+        "LocalObject",
+        "Value"
     };
 
 Slice::Builtin::Builtin(const UnitPtr& unit, Kind kind) :
@@ -368,12 +511,13 @@ string
 Slice::Contained::flattenedScope() const
 {
     string s = scope();
-    string flattenedScope;
-    for(string::const_iterator r = s.begin(); r != s.end(); ++r)
+    string::size_type pos = 0;
+    while((pos = s.find("::", pos)) != string::npos)
     {
-        flattenedScope += ((*r) == ':') ? '_' : *r;
+        s.replace(pos, 2, "_");
+
     }
-    return flattenedScope;
+    return s;
 }
 
 string
@@ -496,12 +640,6 @@ Slice::Contained::operator==(const Contained& rhs) const
     return _scoped == rhs._scoped;
 }
 
-bool
-Slice::Contained::operator!=(const Contained& rhs) const
-{
-    return _scoped != rhs._scoped;
-}
-
 Slice::Contained::Contained(const ContainerPtr& container, const string& name) :
     SyntaxTreeBase(container->unit()),
     _container(container),
@@ -876,17 +1014,6 @@ Slice::Container::createSequence(const string& name, const TypePtr& type, const
 {
     checkIdentifier(name);
 
-    if(_unit->profile() == IceE && !local)
-    {
-        BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
-        if((builtin && builtin->kind() == Builtin::KindObject) || ClassDeclPtr::dynamicCast(type))
-        {
-            string msg = "Sequence `" + name + "' cannot contain object values.";
-            _unit->error(msg);
-            return 0;
-        }
-    }
-
     ContainedList matches = _unit->findContents(thisScope() + name);
     if(!matches.empty())
     {
@@ -930,6 +1057,8 @@ Slice::Container::createSequence(const string& name, const TypePtr& type, const
         _unit->error(msg);
     }
 
+    checkDeprecatedType(_unit, type);
+
     SequencePtr p = new Sequence(this, name, type, metaData, local);
     _contents.push_back(p);
     return p;
@@ -942,17 +1071,6 @@ Slice::Container::createDictionary(const string& name, const TypePtr& keyType, c
 {
     checkIdentifier(name);
 
-    if(_unit->profile() == IceE && !local)
-    {
-        BuiltinPtr builtin = BuiltinPtr::dynamicCast(valueType);
-        if((builtin && builtin->kind() == Builtin::KindObject) || ClassDeclPtr::dynamicCast(valueType))
-        {
-            string msg = "Dictionary `" + name + "' cannot contain object values.";
-            _unit->error(msg);
-            return 0;
-        }
-    }
-
     ContainedList matches = _unit->findContents(thisScope() + name);
     if(!matches.empty())
     {
@@ -997,7 +1115,7 @@ Slice::Container::createDictionary(const string& name, const TypePtr& keyType, c
         }
         if(containsSequence)
         {
-            _unit->warning("use of sequences in dictionary keys has been deprecated");
+            _unit->warning(Deprecated, "use of sequences in dictionary keys has been deprecated");
         }
     }
 
@@ -1015,6 +1133,8 @@ Slice::Container::createDictionary(const string& name, const TypePtr& keyType, c
         }
     }
 
+    checkDeprecatedType(_unit, valueType);
+
     DictionaryPtr p = new Dictionary(this, name, keyType, keyMetaData, valueType, valueMetaData, local);
     _contents.push_back(p);
     return p;
@@ -1068,13 +1188,11 @@ EnumeratorPtr
 Slice::Container::createEnumerator(const string& name)
 {
     EnumeratorPtr p = validateEnumerator(name);
-    if(p)
+    if(!p)
     {
-        return p;
+        p = new Enumerator(this, name);
+        _contents.push_back(p);
     }
-
-    p = new Enumerator(this, name);
-    _contents.push_back(p);
     return p;
 }
 
@@ -1082,13 +1200,11 @@ EnumeratorPtr
 Slice::Container::createEnumerator(const string& name, int value)
 {
     EnumeratorPtr p = validateEnumerator(name);
-    if(p)
+    if(!p)
     {
-        return p;
+        p = new Enumerator(this, name, value);
+        _contents.push_back(p);
     }
-
-    p = new Enumerator(this, name, value);
-    _contents.push_back(p);
     return p;
 }
 
@@ -1133,15 +1249,17 @@ Slice::Container::createConst(const string name, const TypePtr& constType, const
         checkForGlobalDef(name, "constant"); // Don't return here -- we create the constant anyway.
     }
 
+    SyntaxTreeBasePtr resolvedValueType = valueType;
+
     //
-    // Validate the constant and its value.
+    // Validate the constant and its value; for enums, find enumerator
     //
-    if(nt == Real && !validateConstant(name, constType, valueType, value, true))
+    if(nt == Real && !validateConstant(name, constType, resolvedValueType, value, true))
     {
         return 0;
     }
 
-    ConstPtr p = new Const(this, name, constType, metaData, valueType, value, literal);
+    ConstPtr p = new Const(this, name, constType, metaData, resolvedValueType, value, literal);
     _contents.push_back(p);
     return p;
 }
@@ -1178,16 +1296,8 @@ Slice::Container::lookupType(const string& scoped, bool printError)
     return lookupTypeNoBuiltin(scoped, printError);
 }
 
-//
-// TODO: Hack to keep binary compatibility with Ice 3.6.0, fix properly in Ice 3.7
-//
-namespace
-{
-bool ignoreUndefined = false;
-}
-
 TypeList
-Slice::Container::lookupTypeNoBuiltin(const string& scoped, bool printError)
+Slice::Container::lookupTypeNoBuiltin(const string& scoped, bool printError, bool ignoreUndefined)
 {
     //
     // Remove whitespace.
@@ -1304,12 +1414,7 @@ Slice::Container::lookupTypeNoBuiltin(const string& scoped, bool printError)
         ContainedPtr contained = ContainedPtr::dynamicCast(this);
         if(contained)
         {
-            if(typeError)
-            {
-                ignoreUndefined = true;
-            }
-            results = contained->container()->lookupTypeNoBuiltin(sc, printError);
-            ignoreUndefined = false;
+            results = contained->container()->lookupTypeNoBuiltin(sc, printError, typeError || ignoreUndefined);
         }
         else if(!typeError)
         {
@@ -1433,7 +1538,6 @@ Slice::Container::unit() const
     return SyntaxTreeBase::unit();
 }
 
-
 ModuleList
 Slice::Container::modules() const
 {
@@ -1539,6 +1643,86 @@ Slice::Container::enums() const
     return result;
 }
 
+EnumeratorList
+Slice::Container::enumerators() const
+{
+    EnumeratorList result;
+    for(ContainedList::const_iterator p = _contents.begin(); p != _contents.end(); ++p)
+    {
+        EnumeratorPtr q = EnumeratorPtr::dynamicCast(*p);
+        if(q)
+        {
+            result.push_back(q);
+        }
+    }
+    return result;
+}
+
+//
+// Find enumerators using the old unscoped enumerators lookup
+//
+EnumeratorList
+Slice::Container::enumerators(const string& scoped) const
+{
+    EnumeratorList result;
+    string::size_type lastColon = scoped.rfind(':');
+
+    if(lastColon == string::npos)
+    {
+        // check all enclosing scopes
+        ContainerPtr container = const_cast<Container*>(this);
+        do
+        {
+            EnumList enums = container->enums();
+            for(EnumList::iterator p = enums.begin(); p != enums.end(); ++p)
+            {
+                ContainedList cl = (*p)->lookupContained(scoped, false);
+                if(!cl.empty())
+                {
+                    result.push_back(EnumeratorPtr::dynamicCast(cl.front()));
+                }
+            }
+
+            ContainedPtr contained = ContainedPtr::dynamicCast(container);
+            if(contained)
+            {
+                container = contained->container();
+            }
+            else
+            {
+                container = 0;
+            }
+        }
+        while(result.empty() && container);
+    }
+    else
+    {
+        // Find the referenced scope
+        ContainerPtr container = const_cast<Container*>(this);
+        string scope = scoped.substr(0, scoped.rfind("::"));
+        ContainedList cl = container->lookupContained(scope, false);
+        if(!cl.empty())
+        {
+            container = ContainerPtr::dynamicCast(cl.front());
+            if(container)
+            {
+                EnumList enums = container->enums();
+                string name = scoped.substr(lastColon + 1);
+                for(EnumList::iterator p = enums.begin(); p != enums.end(); ++p)
+                {
+                    ContainedList cl = (*p)->lookupContained(name, false);
+                    if(!cl.empty())
+                    {
+                        result.push_back(EnumeratorPtr::dynamicCast(cl.front()));
+                    }
+                }
+            }
+        }
+    }
+
+    return result;
+}
+
 ConstList
 Slice::Container::consts() const
 {
@@ -1610,7 +1794,7 @@ Slice::Container::hasLocalClassDefsWithAsync() const
         ClassDefPtr cl = ClassDefPtr::dynamicCast(*p);
         if(cl && cl->isLocal())
         {
-            if(cl->hasMetaData("async"))
+            if(cl->hasMetaData("async-oneway"))
             {
                 return true;
             }
@@ -1618,7 +1802,7 @@ Slice::Container::hasLocalClassDefsWithAsync() const
             OperationList ol = cl->operations();
             for(OperationList::const_iterator q = ol.begin(); q != ol.end(); ++q)
             {
-                if((*q)->hasMetaData("async"))
+                if((*q)->hasMetaData("async-oneway"))
                 {
                     return true;
                 }
@@ -1677,7 +1861,47 @@ Slice::Container::hasNonLocalExceptions() const
     return false;
 }
 
+bool
+Slice::Container::hasStructs() const
+{
+    for(ContainedList::const_iterator p = _contents.begin(); p != _contents.end(); ++p)
+    {
+        StructPtr q = StructPtr::dynamicCast(*p);
+        if(q)
+        {
+            return true;
+        }
+
+        ContainerPtr container = ContainerPtr::dynamicCast(*p);
+        if(container && container->hasStructs())
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool
+Slice::Container::hasExceptions() const
+{
+    for(ContainedList::const_iterator p = _contents.begin(); p != _contents.end(); ++p)
+    {
+        ExceptionPtr q = ExceptionPtr::dynamicCast(*p);
+        if(q)
+        {
+            return true;
+        }
+
+        ContainerPtr container = ContainerPtr::dynamicCast(*p);
+        if(container && container->hasExceptions())
+        {
+            return true;
+        }
+    }
 
+    return false;
+}
 
 bool
 Slice::Container::hasClassDecls() const
@@ -1774,6 +1998,66 @@ Slice::Container::hasClassDefs() const
     return false;
 }
 
+bool
+Slice::Container::hasLocalClassDefs() const
+{
+    for(ContainedList::const_iterator p = _contents.begin(); p != _contents.end(); ++p)
+    {
+        ClassDefPtr cl = ClassDefPtr::dynamicCast(*p);
+        if(cl && cl->isLocal())
+        {
+            return true;
+        }
+
+        ContainerPtr container = ContainerPtr::dynamicCast(*p);
+        if(container && container->hasLocalClassDefs())
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool
+Slice::Container::hasNonLocalInterfaceDefs() const
+{
+    for(ContainedList::const_iterator p = _contents.begin(); p != _contents.end(); ++p)
+    {
+        ClassDefPtr cl = ClassDefPtr::dynamicCast(*p);
+        if(cl && !cl->isLocal() && (cl->isInterface() || !cl->allOperations().empty()))
+        {
+            return true;
+        }
+
+        ContainerPtr container = ContainerPtr::dynamicCast(*p);
+        if(container && container->hasNonLocalInterfaceDefs())
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool
+Slice::Container::hasValueDefs() const
+{
+    for(ContainedList::const_iterator p = _contents.begin(); p != _contents.end(); ++p)
+    {
+        ClassDefPtr cl = ClassDefPtr::dynamicCast(*p);
+        if(cl && !cl->isLocal() && !cl->isInterface())
+        {
+            return true;
+        }
+
+        ContainerPtr container = ContainerPtr::dynamicCast(*p);
+        if(container && container->hasValueDefs())
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
 bool
 Slice::Container::hasOnlyClassDecls() const
 {
@@ -2001,7 +2285,7 @@ Slice::Container::mergeModules()
             metaData2.unique();
             if(!checkGlobalMetaData(metaData1, metaData2))
             {
-                unit()->warning("global metadata mismatch for module `" + mod1->name() + "' in files " +
+                unit()->warning(All, "global metadata mismatch for module `" + mod1->name() + "' in files " +
                                 dc1->filename() + " and " + dc2->filename());
             }
 
@@ -2310,23 +2594,34 @@ Slice::Container::checkIdentifier(const string& name) const
         //
         // For rules controlled by a translator option, we don't complain about included files.
         //
-        _unit->error("illegal underscore in identifier `" + name + "'");
+
+        DefinitionContextPtr dc = _unit->currentDefinitionContext();
+        assert(dc);
+        if(dc->findMetaData("underscore") != "underscore") // no "underscore" global metadata
+        {
+            _unit->error("illegal underscore in identifier `" + name + "'");
+        }
     }
 
+    //
+    // For rules controlled by a translator option, we don't complain about included files.
+    //
     if(_unit->currentIncludeLevel() == 0 && !_unit->allowIcePrefix())
     {
-        //
-        // For rules controlled by a translator option, we don't complain about included files.
-        //
-        if(name.size() >= 3)
+        DefinitionContextPtr dc = _unit->currentDefinitionContext();
+        assert(dc);
+        if(dc->findMetaData("ice-prefix") != "ice-prefix") // no "ice-prefix" global metadata
         {
-            string prefix3;
-            prefix3 += ::tolower(static_cast<unsigned char>(name[0]));
-            prefix3 += ::tolower(static_cast<unsigned char>(name[1]));
-            prefix3 += ::tolower(static_cast<unsigned char>(name[2]));
-            if(prefix3 == "ice")
+            if(name.size() >= 3)
             {
-                _unit->error("illegal identifier `" + name + "': `" + name.substr(0, 3) + "' prefix is reserved");
+                string prefix3;
+                prefix3 += ::tolower(static_cast<unsigned char>(name[0]));
+                prefix3 += ::tolower(static_cast<unsigned char>(name[1]));
+                prefix3 += ::tolower(static_cast<unsigned char>(name[2]));
+                if(prefix3 == "ice")
+                {
+                    _unit->error("illegal identifier `" + name + "': `" + name.substr(0, 3) + "' prefix is reserved");
+                }
             }
         }
     }
@@ -2429,7 +2724,7 @@ Slice::Container::checkGlobalMetaData(const StringList& m1, const StringList& m2
 }
 
 bool
-Slice::Container::validateConstant(const string& name, const TypePtr& type, const SyntaxTreeBasePtr& valueType,
+Slice::Container::validateConstant(const string& name, const TypePtr& type, SyntaxTreeBasePtr& valueType,
                                    const string& value, bool isConstant)
 {
     //
@@ -2575,6 +2870,7 @@ Slice::Container::validateConstant(const string& name, const TypePtr& type, cons
                 case Builtin::KindObject:
                 case Builtin::KindObjectProxy:
                 case Builtin::KindLocalObject:
+                case Builtin::KindValue:
                 {
                     assert(false);
                     break;
@@ -2657,20 +2953,57 @@ Slice::Container::validateConstant(const string& name, const TypePtr& type, cons
         }
         else
         {
-            EnumeratorPtr lte = EnumeratorPtr::dynamicCast(valueType);
-
-            if(!lte)
+            if(valueType)
             {
-                string msg = "type of initializer is incompatible with the type of " + desc + " `" + name + "'";
-                _unit->error(msg);
-                return false;
+                EnumeratorPtr lte = EnumeratorPtr::dynamicCast(valueType);
+
+                if(!lte)
+                {
+                    string msg = "type of initializer is incompatible with the type of " + desc + " `" + name + "'";
+                    _unit->error(msg);
+                    return false;
+                }
+                EnumeratorList elist = e->enumerators();
+                if(find(elist.begin(), elist.end(), lte) == elist.end())
+                {
+                    string msg = "enumerator `" + value + "' is not defined in enumeration `" + e->scoped() + "'";
+                    _unit->error(msg);
+                    return false;
+                }
             }
-            EnumeratorList elist = e->getEnumerators();
-            if(find(elist.begin(), elist.end(), lte) == elist.end())
+            else
             {
-                string msg = "enumerator `" + value + "' is not defined in enumeration `" + e->scoped() + "'";
-                _unit->error(msg);
-                return false;
+                // Check if value designates an enumerator of e
+                string newVal = value;
+                string::size_type lastColon = value.rfind(':');
+                if(lastColon != string::npos && lastColon + 1 < value.length())
+                {
+                    newVal = value.substr(0, lastColon + 1) + e->name() + "::" + value.substr(lastColon + 1);
+                }
+
+                ContainedList clist = e->lookupContained(newVal, false);
+                if(clist.empty())
+                {
+                    string msg = "`" + value + "' does not designate an enumerator of `" + e->scoped() + "'";
+                    _unit->error(msg);
+                    return false;
+                }
+                EnumeratorPtr lte = EnumeratorPtr::dynamicCast(clist.front());
+                if(lte)
+                {
+                    valueType = lte;
+                    if(lastColon != string::npos)
+                    {
+                        _unit->warning(Deprecated, string("referencing enumerator `") + lte->name() +
+                                       "' in its enumeration's enclosing scope is deprecated");
+                    }
+                }
+                else
+                {
+                    string msg = "type of initializer is incompatible with the type of " + desc + " `" + name + "'";
+                    _unit->error(msg);
+                    return false;
+                }
             }
         }
     }
@@ -2697,20 +3030,17 @@ Slice::Container::validateEnumerator(const string& name)
         }
         if(matches.front()->name() == name)
         {
-            string msg = "redefinition of " + matches.front()->kindOf() + " `" + matches.front()->name();
-            msg += "' as enumerator";
-            _unit->error(msg);
+            _unit->error(string("redefinition of enumerator `") + name + "'");
         }
         else
         {
             string msg = "enumerator `" + name + "' differs only in capitalization from ";
-            msg += matches.front()->kindOf() + " `" + matches.front()->name() + "'";
+            msg += "`" + matches.front()->name() + "'";
             _unit->error(msg);
         }
     }
 
-    nameIsLegal(name, "enumerator"); // Don't return here -- we create the enumerator anyway.
-
+    nameIsLegal(name, "enumerator"); // Ignore return value.
     return 0;
 }
 
@@ -3186,6 +3516,12 @@ Slice::ClassDef::createOperation(const string& name,
         _unit->error(msg);
     }
 
+    if(!isInterface() && !isLocal() && !_hasOperations)
+    {
+        // Only warn for the first operation
+        _unit->warning(Deprecated, "classes with operations are deprecated");
+    }
+
     _hasOperations = true;
     OperationPtr op = new Operation(this, name, returnType, optional, tag, mode);
     _contents.push_back(op);
@@ -3199,28 +3535,6 @@ Slice::ClassDef::createDataMember(const string& name, const TypePtr& type, bool
 {
     checkIdentifier(name);
 
-    if(_unit->profile() == IceE)
-    {
-        if(!isLocal())
-        {
-            BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
-            if((builtin && builtin->kind() == Builtin::KindObject))
-            {
-                string msg = "Class data member `" + name + "' cannot be a value object.";
-                _unit->error(msg);
-                return 0;
-            }
-
-            ClassDeclPtr classDecl = ClassDeclPtr::dynamicCast(type);
-            if(classDecl != 0 && !classDecl->isLocal())
-            {
-                string msg = "Class data member `" + name + "' cannot be a value object.";
-                _unit->error(msg);
-                return 0;
-            }
-        }
-    }
-
     assert(!isInterface());
     ContainedList matches = _unit->findContents(thisScope() + name);
     if(!matches.empty())
@@ -3303,7 +3617,7 @@ Slice::ClassDef::createDataMember(const string& name, const TypePtr& type, bool
     string dv = defaultValue;
     string dl = defaultLiteral;
 
-    if(dlt)
+    if(dlt || (EnumPtr::dynamicCast(type) && !dv.empty()))
     {
         //
         // Validate the default value.
@@ -3336,6 +3650,8 @@ Slice::ClassDef::createDataMember(const string& name, const TypePtr& type, bool
         }
     }
 
+    checkDeprecatedType(_unit, type);
+
     _hasDataMembers = true;
     DataMemberPtr member = new DataMember(this, name, type, optional, tag, dlt, dv, dl);
     _contents.push_back(member);
@@ -3456,7 +3772,9 @@ Slice::ClassDef::classDataMembers() const
         if(q)
         {
             BuiltinPtr builtin = BuiltinPtr::dynamicCast(q->type());
-            if((builtin && builtin->kind() == Builtin::KindObject) || ClassDeclPtr::dynamicCast(q->type()))
+            if((builtin && builtin->kind() == Builtin::KindObject) ||
+               (builtin && builtin->kind() == Builtin::KindValue) ||
+               ClassDeclPtr::dynamicCast(q->type()))
             {
                 result.push_back(q);
             }
@@ -3603,6 +3921,17 @@ Slice::ClassDef::inheritsMetaData(const string& meta) const
     return false;
 }
 
+bool
+Slice::ClassDef::hasBaseDataMembers() const
+{
+    if(!_bases.empty() && !_bases.front()->isInterface())
+    {
+        return !_bases.front()->allDataMembers().empty();
+    }
+
+    return false;
+}
+
 Contained::ContainedType
 Slice::ClassDef::containedType() const
 {
@@ -3645,6 +3974,11 @@ Slice::ClassDef::compactId() const
     return _compactId;
 }
 
+bool
+Slice::ClassDef::isDelegate() const
+{
+    return isLocal() && isInterface() && hasMetaData("delegate") && allOperations().size() == 1;
+}
 Slice::ClassDef::ClassDef(const ContainerPtr& container, const string& name, int id, bool intf, const ClassList& bases,
                           bool local) :
     SyntaxTreeBase(container->unit()),
@@ -3657,6 +3991,17 @@ Slice::ClassDef::ClassDef(const ContainerPtr& container, const string& name, int
     _local(local),
     _compactId(id)
 {
+    if(!local && !intf)
+    {
+        for(ClassList::const_iterator p = _bases.begin(); p != _bases.end(); ++p)
+        {
+            if((*p)->isInterface())
+            {
+                _unit->warning(Deprecated, "classes implementing interfaces are deprecated");
+                break;
+            }
+        }
+    }
     //
     // First element of bases may be a class, all others must be
     // interfaces.
@@ -3681,13 +4026,13 @@ Slice::ClassDef::ClassDef(const ContainerPtr& container, const string& name, int
 bool
 Slice::Proxy::isLocal() const
 {
-    return __class->isLocal();
+    return _classDecl->isLocal();
 }
 
 string
 Slice::Proxy::typeId() const
 {
-    return __class->scoped();
+    return _classDecl->scoped();
 }
 
 bool
@@ -3711,13 +4056,13 @@ Slice::Proxy::isVariableLength() const
 ClassDeclPtr
 Slice::Proxy::_class() const
 {
-    return __class;
+    return _classDecl;
 }
 
 Slice::Proxy::Proxy(const ClassDeclPtr& cl) :
      SyntaxTreeBase(cl->unit()),
      Type(cl->unit()),
-    __class(cl)
+    _classDecl(cl)
 {
 }
 
@@ -3739,28 +4084,6 @@ Slice::Exception::createDataMember(const string& name, const TypePtr& type, bool
 {
     checkIdentifier(name);
 
-    if(_unit->profile() == IceE)
-    {
-        if(!isLocal())
-        {
-            BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
-            if((builtin && builtin->kind() == Builtin::KindObject))
-            {
-                string msg = "Exception data member `" + name + "' cannot be a value object.";
-                _unit->error(msg);
-                return 0;
-            }
-
-            ClassDeclPtr classDecl = ClassDeclPtr::dynamicCast(type);
-            if(classDecl != 0 && !classDecl->isLocal())
-            {
-                string msg = "Exception data member `" + name + "' cannot be a value object.";
-                _unit->error(msg);
-                return 0;
-            }
-        }
-    }
-
     ContainedList matches = _unit->findContents(thisScope() + name);
     if(!matches.empty())
     {
@@ -3830,7 +4153,7 @@ Slice::Exception::createDataMember(const string& name, const TypePtr& type, bool
     string dv = defaultValue;
     string dl = defaultLiteral;
 
-    if(dlt)
+    if(dlt || (EnumPtr::dynamicCast(type) && !dv.empty()))
     {
         //
         // Validate the default value.
@@ -3863,6 +4186,8 @@ Slice::Exception::createDataMember(const string& name, const TypePtr& type, bool
         }
     }
 
+    checkDeprecatedType(_unit, type);
+
     DataMemberPtr p = new DataMember(this, name, type, optional, tag, dlt, dv, dl);
     _contents.push_back(p);
     return p;
@@ -3925,7 +4250,9 @@ Slice::Exception::classDataMembers() const
         if(q)
         {
             BuiltinPtr builtin = BuiltinPtr::dynamicCast(q->type());
-            if((builtin && builtin->kind() == Builtin::KindObject) || ClassDeclPtr::dynamicCast(q->type()))
+            if((builtin && builtin->kind() == Builtin::KindObject) ||
+               (builtin && builtin->kind() == Builtin::KindValue) ||
+               ClassDeclPtr::dynamicCast(q->type()))
             {
                 result.push_back(q);
             }
@@ -4059,6 +4386,12 @@ Slice::Exception::inheritsMetaData(const string& meta) const
     return false;
 }
 
+bool
+Slice::Exception::hasBaseDataMembers() const
+{
+    return _base && !_base->allDataMembers().empty();
+}
+
 string
 Slice::Exception::kindOf() const
 {
@@ -4093,29 +4426,6 @@ Slice::Struct::createDataMember(const string& name, const TypePtr& type, bool op
                                 const SyntaxTreeBasePtr& defaultValueType, const string& defaultValue,
                                 const string& defaultLiteral)
 {
-    checkIdentifier(name);
-
-    if(_unit->profile() == IceE)
-    {
-        if(!isLocal())
-        {
-            BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
-            if((builtin && builtin->kind() == Builtin::KindObject))
-            {
-                string msg = "Struct data member `" + name + "' cannot be a value object.";
-                _unit->error(msg);
-                return 0;
-            }
-            ClassDeclPtr classDecl = ClassDeclPtr::dynamicCast(type);
-            if(classDecl != 0 && !classDecl->isLocal())
-            {
-                string msg = "Struct data member `" + name + "' cannot be a value object.";
-                _unit->error(msg);
-                return 0;
-            }
-        }
-    }
-
     ContainedList matches = _unit->findContents(thisScope() + name);
     if(!matches.empty())
     {
@@ -4167,7 +4477,7 @@ Slice::Struct::createDataMember(const string& name, const TypePtr& type, bool op
     string dv = defaultValue;
     string dl = defaultLiteral;
 
-    if(dlt)
+    if(dlt || (EnumPtr::dynamicCast(type) && !dv.empty()))
     {
         //
         // Validate the default value.
@@ -4200,6 +4510,8 @@ Slice::Struct::createDataMember(const string& name, const TypePtr& type, bool op
         }
     }
 
+    checkDeprecatedType(_unit, type);
+
     DataMemberPtr p = new DataMember(this, name, type, optional, tag, dlt, dv, dl);
     _contents.push_back(p);
     return p;
@@ -4230,7 +4542,9 @@ Slice::Struct::classDataMembers() const
         if(q)
         {
             BuiltinPtr builtin = BuiltinPtr::dynamicCast(q->type());
-            if((builtin && builtin->kind() == Builtin::KindObject) || ClassDeclPtr::dynamicCast(q->type()))
+            if((builtin && builtin->kind() == Builtin::KindObject) ||
+               (builtin && builtin->kind() == Builtin::KindValue) ||
+               ClassDeclPtr::dynamicCast(q->type()))
             {
                 result.push_back(q);
             }
@@ -4569,6 +4883,7 @@ Slice::Dictionary::legalKeyType(const TypePtr& type, bool& containsSequence)
             case Builtin::KindObject:
             case Builtin::KindObjectProxy:
             case Builtin::KindLocalObject:
+            case Builtin::KindValue:
             {
                 return false;
                 break;
@@ -4630,71 +4945,9 @@ Slice::Dictionary::Dictionary(const ContainerPtr& container, const string& name,
 void
 Slice::Enum::destroy()
 {
-    _enumerators.clear();
     SyntaxTreeBase::destroy();
 }
 
-EnumeratorList
-Slice::Enum::getEnumerators()
-{
-    return _enumerators;
-}
-
-void
-Slice::Enum::setEnumerators(const EnumeratorList& ens)
-{
-    _enumerators = ens;
-    int lastValue = -1;
-    set<int> values;
-    for(EnumeratorList::iterator p = _enumerators.begin(); p != _enumerators.end(); ++p)
-    {
-        (*p)->_type = this;
-
-        if((*p)->_explicitValue)
-        {
-            _explicitValue = true;
-
-            if((*p)->_value < 0)
-            {
-                string msg = "value for enumerator `" + (*p)->name() + "' is out of range";
-                _unit->error(msg);
-            }
-        }
-        else
-        {
-            if(lastValue == Int32Max)
-            {
-                string msg = "value for enumerator `" + (*p)->name() + "' is out of range";
-                _unit->error(msg);
-            }
-
-            //
-            // If the enumerator was not assigned an explicit value, we automatically assign
-            // it one more than the previous enumerator.
-            //
-            (*p)->_value = lastValue + 1;
-        }
-
-        if(values.count((*p)->_value) != 0)
-        {
-            string msg = "enumerator `" + (*p)->name() + "' has a duplicate value";
-            _unit->error(msg);
-        }
-        values.insert((*p)->_value);
-
-        lastValue = (*p)->_value;
-
-        if(lastValue > _maxValue)
-        {
-            _maxValue = lastValue;
-        }
-        if(lastValue < _minValue)
-        {
-            _minValue = lastValue;
-        }
-    }
-}
-
 bool
 Slice::Enum::explicitValue() const
 {
@@ -4763,15 +5016,77 @@ Slice::Enum::recDependencies(set<ConstructedPtr>&)
 
 Slice::Enum::Enum(const ContainerPtr& container, const string& name, bool local) :
     SyntaxTreeBase(container->unit()),
+    Container(container->unit()),
     Type(container->unit()),
     Contained(container, name),
     Constructed(container, name, local),
     _explicitValue(false),
     _minValue(Int32Max),
-    _maxValue(0)
+    _maxValue(0),
+    _lastValue(-1)
 {
 }
 
+int
+Slice::Enum::newEnumerator(const EnumeratorPtr& p)
+{
+    if(p->explicitValue())
+    {
+        _explicitValue = true;
+        _lastValue = p->value();
+
+        if(_lastValue < 0)
+        {
+            string msg = "value for enumerator `" + p->name() + "' is out of range";
+            _unit->error(msg);
+        }
+    }
+    else
+    {
+        if(_lastValue == Int32Max)
+        {
+            string msg = "value for enumerator `" + p->name() + "' is out of range";
+            _unit->error(msg);
+        }
+        else
+        {
+            //
+            // If the enumerator was not assigned an explicit value, we automatically assign
+            // it one more than the previous enumerator.
+            //
+            ++_lastValue;
+        }
+    }
+
+    bool checkForDuplicates = true;
+    if(_lastValue > _maxValue)
+    {
+        _maxValue = _lastValue;
+        checkForDuplicates = false;
+    }
+    if(_lastValue < _minValue)
+    {
+        _minValue = _lastValue;
+        checkForDuplicates = false;
+    }
+
+    if(checkForDuplicates)
+    {
+        EnumeratorList enl = enumerators();
+        for(EnumeratorList::iterator q = enl.begin(); q != enl.end(); ++q)
+        {
+            EnumeratorPtr& r = *q;
+            if(r != p && r->value() == _lastValue)
+            {
+                _unit->error(string("enumerator `") + p->name() + "' has the same value as enumerator `" +
+                             r->name() + "'");
+            }
+        }
+    }
+
+    return _lastValue;
+}
+
 // ----------------------------------------------------------------------
 // Enumerator
 // ----------------------------------------------------------------------
@@ -4779,7 +5094,7 @@ Slice::Enum::Enum(const ContainerPtr& container, const string& name, bool local)
 EnumPtr
 Slice::Enumerator::type() const
 {
-    return _type;
+    return EnumPtr::dynamicCast(container());
 }
 
 Contained::ContainedType
@@ -4818,6 +5133,7 @@ Slice::Enumerator::Enumerator(const ContainerPtr& container, const string& name)
     _explicitValue(false),
     _value(-1)
 {
+    _value = EnumPtr::dynamicCast(container)->newEnumerator(this);
 }
 
 Slice::Enumerator::Enumerator(const ContainerPtr& container, const string& name, int value) :
@@ -4826,6 +5142,7 @@ Slice::Enumerator::Enumerator(const ContainerPtr& container, const string& name,
     _explicitValue(true),
     _value(value)
 {
+    EnumPtr::dynamicCast(container)->newEnumerator(this);
 }
 
 // ----------------------------------------------------------------------
@@ -4898,6 +5215,11 @@ Slice::Const::Const(const ContainerPtr& container, const string& name, const Typ
     _value(value),
     _literal(literal)
 {
+    if(valueType == 0)
+    {
+        cerr << "const " << name << " created with null valueType" << endl;
+    }
+
 }
 
 // ----------------------------------------------------------------------
@@ -4941,33 +5263,33 @@ Slice::Operation::sendMode() const
     }
 }
 
-ParamDeclPtr
-Slice::Operation::createParamDecl(const string& name, const TypePtr& type, bool isOutParam, bool optional, int tag)
+bool
+Slice::Operation::hasMarshaledResult() const
 {
-    checkIdentifier(name);
-
-    if(_unit->profile() == IceE)
+    ClassDefPtr cl = ClassDefPtr::dynamicCast(container());
+    assert(cl);
+    if(cl->hasMetaData("marshaled-result") || hasMetaData("marshaled-result"))
     {
-        ClassDefPtr cl = ClassDefPtr::dynamicCast(this->container());
-        assert(cl);
-        if(!cl->isLocal())
+        if(returnType() && isMutableAfterReturnType(returnType()))
         {
-            BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
-            if((builtin && builtin->kind() == Builtin::KindObject))
-            {
-                string msg = "Object `" + name + "' cannot be passed by value.";
-                _unit->error(msg);
-                return 0;
-            }
-            ClassDeclPtr classDecl =  ClassDeclPtr::dynamicCast(type);
-            if(classDecl != 0 && !classDecl->isLocal())
+            return true;
+        }
+        for(ContainedList::const_iterator p = _contents.begin(); p != _contents.end(); ++p)
+        {
+            ParamDeclPtr q = ParamDeclPtr::dynamicCast(*p);
+            if(q->isOutParam() && isMutableAfterReturnType(q->type()))
             {
-                string msg = "Object `" + name + "' cannot be passed by value.";
-                _unit->error(msg);
-                return 0;
+                return true;
             }
         }
     }
+    return false;
+}
+
+ParamDeclPtr
+Slice::Operation::createParamDecl(const string& name, const TypePtr& type, bool isOutParam, bool optional, int tag)
+{
+    checkIdentifier(name);
 
     ContainedList matches = _unit->findContents(thisScope() + name);
     if(!matches.empty())
@@ -5023,6 +5345,11 @@ Slice::Operation::createParamDecl(const string& name, const TypePtr& type, bool
         _unit->error(msg);
     }
 
+    //
+    // Issue a warning for a deprecated parameter type.
+    //
+    checkDeprecatedType(_unit, type);
+
     if(optional)
     {
         //
@@ -5067,6 +5394,74 @@ Slice::Operation::parameters() const
     return result;
 }
 
+ParamDeclList
+Slice::Operation::inParameters() const
+{
+    ParamDeclList result;
+    for(ContainedList::const_iterator p = _contents.begin(); p != _contents.end(); ++p)
+    {
+        ParamDeclPtr q = ParamDeclPtr::dynamicCast(*p);
+        if(q && !q->isOutParam())
+        {
+            result.push_back(q);
+        }
+    }
+    return result;
+}
+
+void
+Slice::Operation::inParameters(ParamDeclList& required, ParamDeclList& optional) const
+{
+    const ParamDeclList params = inParameters();
+    for(ParamDeclList::const_iterator pli = params.begin(); pli != params.end(); ++pli)
+    {
+        if((*pli)->optional())
+        {
+            optional.push_back(*pli);
+        }
+        else
+        {
+            required.push_back(*pli);
+        }
+    }
+
+    sortOptionalParameters(optional);
+}
+
+ParamDeclList
+Slice::Operation::outParameters() const
+{
+    ParamDeclList result;
+    for(ContainedList::const_iterator p = _contents.begin(); p != _contents.end(); ++p)
+    {
+        ParamDeclPtr q = ParamDeclPtr::dynamicCast(*p);
+        if(q && q->isOutParam())
+        {
+            result.push_back(q);
+        }
+    }
+    return result;
+}
+
+void
+Slice::Operation::outParameters(ParamDeclList& required, ParamDeclList& optional) const
+{
+    const ParamDeclList params = outParameters();
+    for(ParamDeclList::const_iterator pli = params.begin(); pli != params.end(); ++pli)
+    {
+        if((*pli)->optional())
+        {
+            optional.push_back(*pli);
+        }
+        else
+        {
+            required.push_back(*pli);
+        }
+    }
+
+    sortOptionalParameters(optional);
+}
+
 ExceptionList
 Slice::Operation::throws() const
 {
@@ -5218,13 +5613,26 @@ Slice::Operation::returnsData() const
     return false;
 }
 
+bool
+Slice::Operation::returnsMultipleValues() const
+{
+    size_t count = outParameters().size();
+
+    if(returnType())
+    {
+        ++count;
+    }
+
+    return count > 1;
+}
+
 bool
 Slice::Operation::sendsOptionals() const
 {
-    ParamDeclList pdl = parameters();
+    ParamDeclList pdl = inParameters();
     for(ParamDeclList::const_iterator i = pdl.begin(); i != pdl.end(); ++i)
     {
-        if(!(*i)->isOutParam() && (*i)->optional())
+        if((*i)->optional())
         {
             return true;
         }
@@ -5263,7 +5671,7 @@ Slice::Operation::attributes() const
         }
         if(i == 2)
         {
-            emitWarning(definitionContext()->filename(), line(), "invalid freeze metadata for operation");
+            _unit->warning(InvalidMetaData, "invalid freeze metadata for operation");
         }
         else
         {
@@ -5284,7 +5692,7 @@ Slice::Operation::attributes() const
                 {
                     if(result != 0 && (i == int(Supports) || i == int(Never)))
                     {
-                        emitWarning(definitionContext()->filename(), line(), "invalid freeze metadata for operation");
+                        _unit->warning(InvalidMetaData, "invalid freeze metadata for operation");
                     }
                     else
                     {
@@ -5298,7 +5706,7 @@ Slice::Operation::attributes() const
 
             if(i == 4)
             {
-                emitWarning(definitionContext()->filename(), line(), "invalid freeze metadata for operation");
+                _unit->warning(InvalidMetaData, "invalid freeze metadata for operation");
 
                 //
                 // Set default
@@ -5356,25 +5764,9 @@ Slice::Operation::Operation(const ContainerPtr& container,
     _returnTag(returnTag),
     _mode(mode)
 {
-    if(_unit->profile() == IceE)
+    if(returnType)
     {
-        ClassDefPtr cl = ClassDefPtr::dynamicCast(this->container());
-        assert(cl);
-        if(!cl->isLocal())
-        {
-            BuiltinPtr builtin = BuiltinPtr::dynamicCast(returnType);
-            if((builtin && builtin->kind() == Builtin::KindObject))
-            {
-                string msg = "Method `" + name + "' cannot return an object by value.";
-                _unit->error(msg);
-            }
-            ClassDeclPtr classDecl = ClassDeclPtr::dynamicCast(returnType);
-            if(classDecl != 0 && !classDecl->isLocal())
-            {
-                string msg = "Method `" + name + "' cannot return an object by value.";
-                _unit->error(msg);
-            }
-        }
+        checkDeprecatedType(_unit, returnType);
     }
 }
 
@@ -5800,13 +6192,6 @@ Slice::Unit::setSeenDefinition()
     dc->setSeenDefinition();
 }
 
-void
-Slice::Unit::error(const char* s)
-{
-    emitError(currentFile(), _currentLine, s);
-    _errors++;
-}
-
 void
 Slice::Unit::error(const string& s)
 {
@@ -5815,15 +6200,16 @@ Slice::Unit::error(const string& s)
 }
 
 void
-Slice::Unit::warning(const char* s) const
-{
-    emitWarning(currentFile(), _currentLine, s);
-}
-
-void
-Slice::Unit::warning(const string& s) const
+Slice::Unit::warning(WarningCategory category, const string& msg) const
 {
-    emitWarning(currentFile(), _currentLine, s);
+    if(_definitionContextStack.empty())
+    {
+        emitWarning(currentFile(), _currentLine, msg);
+    }
+    else
+    {
+        _definitionContextStack.top()->warning(category, currentFile(), _currentLine, msg);
+    }
 }
 
 ContainerPtr
@@ -6038,6 +6424,11 @@ Slice::Unit::usesNonLocals() const
         return true;
     }
 
+    if(_builtins.find(Builtin::KindValue) != _builtins.end())
+    {
+        return true;
+    }
+
     return false;
 }
 
@@ -6059,12 +6450,6 @@ Slice::Unit::usesConsts() const
     return false;
 }
 
-FeatureProfile
-Slice::Unit::profile() const
-{
-    return _featureProfile;
-}
-
 StringList
 Slice::Unit::includeFiles() const
 {
@@ -6084,7 +6469,7 @@ Slice::Unit::allFiles() const
 }
 
 int
-Slice::Unit::parse(const string& filename, FILE* file, bool debug, Slice::FeatureProfile profile)
+Slice::Unit::parse(const string& filename, FILE* file, bool debug)
 {
     slice_debug = debug ? 1 : 0;
 
@@ -6094,7 +6479,6 @@ Slice::Unit::parse(const string& filename, FILE* file, bool debug, Slice::Featur
     _currentComment = "";
     _currentLine = 1;
     _currentIncludeLevel = 0;
-    _featureProfile = profile;
     _topLevelFile = fullPath(filename);
     pushContainer(this);
     pushDefinitionContext();
@@ -6130,6 +6514,11 @@ Slice::Unit::parse(const string& filename, FILE* file, bool debug, Slice::Featur
         popContainer();
         assert(_definitionContextStack.size() == 1);
         popDefinitionContext();
+
+        if(!checkUndefinedTypes())
+        {
+            status = EXIT_FAILURE;
+        }
     }
 
     Slice::unit = 0;
@@ -6228,6 +6617,113 @@ Slice::Unit::eraseWhiteSpace(string& s)
     }
 }
 
+bool
+Slice::Unit::checkUndefinedTypes()
+{
+    class Visitor : public ParserVisitor
+    {
+    public:
+
+        Visitor(int& errors) :
+            _errors(errors),
+            _local(false)
+        {
+        }
+
+        virtual bool visitClassDefStart(const ClassDefPtr& p)
+        {
+            _local = p->isLocal();
+            return true;
+        }
+
+        virtual bool visitExceptionStart(const ExceptionPtr& p)
+        {
+            _local = p->isLocal();
+            return true;
+        }
+
+        virtual bool visitStructStart(const StructPtr& p)
+        {
+            _local = p->isLocal();
+            return true;
+        }
+
+        virtual void visitOperation(const OperationPtr& p)
+        {
+            if(p->returnType())
+            {
+                checkUndefined(p->returnType(), "return type", p->file(), p->line());
+            }
+            ParamDeclList params = p->parameters();
+            for(ParamDeclList::const_iterator q = params.begin(); q != params.end(); ++q)
+            {
+                checkUndefined((*q)->type(), "parameter " + (*q)->name(), (*q)->file(), (*q)->line());
+            }
+        }
+
+        virtual void visitParamDecl(const ParamDeclPtr& p)
+        {
+            checkUndefined(p->type(), "parameter " + p->name(), p->file(), p->line());
+        }
+
+        virtual void visitDataMember(const DataMemberPtr& p)
+        {
+            checkUndefined(p->type(), "member " + p->name(), p->file(), p->line());
+        }
+
+        virtual void visitSequence(const SequencePtr& p)
+        {
+            _local = p->isLocal();
+            checkUndefined(p->type(), "element type", p->file(), p->line());
+        }
+
+        virtual void visitDictionary(const DictionaryPtr& p)
+        {
+            _local = p->isLocal();
+            checkUndefined(p->keyType(), "key type", p->file(), p->line());
+            checkUndefined(p->valueType(), "value type", p->file(), p->line());
+        }
+
+    private:
+
+        void checkUndefined(const TypePtr& type, const string& desc, const string& file, const string& line)
+        {
+            //
+            // See ICE-6867. Any use of a proxy requires the full type definition, as does any
+            // use of a class in a non-local context.
+            //
+            ProxyPtr p = ProxyPtr::dynamicCast(type);
+            if(p)
+            {
+                const ClassDeclPtr cl = p->_class();
+                if(!cl->definition())
+                {
+                    ostringstream ostr;
+                    ostr << desc << " uses a proxy for undefined type `" << cl->scoped() << "'";
+                    emitError(file, line, ostr.str());
+                    _errors++;
+                }
+            }
+
+            ClassDeclPtr cl = ClassDeclPtr::dynamicCast(type);
+            if(cl && !cl->definition() && !_local)
+            {
+                ostringstream ostr;
+                ostr << desc << " refers to undefined type `" << cl->scoped() << "'";
+                emitError(file, line, ostr.str());
+                _errors++;
+            }
+        }
+
+        int& _errors;
+        bool _local;
+    };
+
+    Visitor v(_errors);
+    visit(&v, true);
+    return _errors == 0;
+}
+
 // ----------------------------------------------------------------------
 // CICompare
 // ----------------------------------------------------------------------
@@ -6270,7 +6766,6 @@ Slice::cICompare(const std::string& s1, const std::string& s2)
 }
 #endif
 
-
 // ----------------------------------------------------------------------
 // DerivedToBaseCompare
 // ----------------------------------------------------------------------