zeroc-ice 3.6.5 → 3.7.4

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

@@ -1,14 +1,11 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 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.
-//
-// **********************************************************************
 
 #include <Slice/PHPUtil.h>
 #include <functional>
+#include <algorithm>
+#include <vector>
 
 using namespace std;
 using namespace Slice;
@@ -17,7 +14,12 @@ static string
 lowerCase(const string& s)
 {
     string result(s);
+#ifdef ICE_CPP11_COMPILER
+    transform(result.begin(), result.end(), result.begin(),
+              [](char c){ return static_cast<char>(::tolower(static_cast<unsigned char>(c))); });
+#else
     transform(result.begin(), result.end(), result.begin(), ::tolower);
+#endif
     return result;
 }
 
@@ -29,14 +31,15 @@ lookupKwd(const string& name)
     //
     // Keyword list. *Must* be kept in alphabetical order.
     //
-    static const string keywordList[] = 
-    {       
-        "abstract", "and", "array", "as", "break", "case", "catch", "class", "clone", "const", "continue", "declare",
-        "default", "die", "do", "echo", "else", "elseif", "empty", "enddeclare", "endfor", "endforeach", "endif",
-        "endswitch", "endwhile", "eval", "exit", "extends", "final", "for", "foreach", "function", "global", "if",
-        "implements", "include", "include_once", "interface", "isset", "list", "new", "or", "print", "private",
-        "protected", "public", "require", "require_once", "return", "static", "switch", "this", "throw", "try",
-        "unset", "use", "var", "while", "xor"
+    static const string keywordList[] =
+    {
+        "_halt_compiler", "abstract", "and", "array", "as", "break", "callable", "case", "catch", "class", "clone",
+        "const", "continue", "declare", "default", "die", "do", "echo", "else", "elseif", "empty", "enddeclare",
+        "endfor", "endforeach", "endif", "endswitch", "endwhile", "eval", "exit", "extends", "final", "finally",
+        "for", "foreach", "function", "global", "goto", "if", "implements", "include", "include_once", "instanceof",
+        "insteadof", "interface", "isset", "list", "namespace", "new", "or", "print", "private", "protected", "public",
+        "require", "require_once", "return", "static", "switch", "this", "throw", "trait", "try", "unset", "use", "var",
+        "while", "xor", "yield"
     };
     bool found =  binary_search(&keywordList[0],
                                 &keywordList[sizeof(keywordList) / sizeof(*keywordList)],
@@ -134,12 +137,6 @@ Slice::PHP::fixIdent(const string& ident)
     return result.str();
 }
 
-string
-Slice::PHP::getAbsolute(const ContainedPtr& cont, bool ns, const string& prefix, const string& suffix)
-{
-    return scopedToName(cont->scope() + prefix + cont->name() + suffix, ns);
-}
-
 string
 Slice::PHP::escapeName(const string& name)
 {

data/ext/ice/cpp/src/Slice/PHPUtil.h

@@ -0,0 +1,36 @@
+//
+// Copyright (c) ZeroC, Inc. All rights reserved.
+//
+
+#ifndef SLICE_PHP_UTIL_H
+#define SLICE_PHP_UTIL_H
+
+#include <IceUtil/Config.h>
+#include <string>
+
+namespace Slice
+{
+namespace PHP
+{
+
+//
+// Convert a scoped name into a PHP name.
+//
+std::string scopedToName(const std::string&, bool);
+
+//
+// Check the given identifier against PHP's list of reserved words. If it matches
+// a reserved word, then an escaped version is returned with a leading underscore.
+//
+std::string fixIdent(const std::string&);
+
+//
+// Since PHP uses the backslash character as the namespace separator, we have
+// to escape backslash characters when they appear in a string literal.
+//
+std::string escapeName(const std::string&);
+
+}
+}
+
+#endif

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 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.
-//
-// **********************************************************************
 
 #include <IceUtil/Functional.h>
 #include <IceUtil/InputUtil.h>
@@ -16,16 +11,64 @@
 #include <cstring>
 #include <iterator>
 
-#ifdef _WIN32
-#   include <io.h>
+// TODO: fix this warning once we no longer support VS2013 and earlier
+#if defined(_MSC_VER) && (_MSC_VER >= 1900)
+#    pragma warning(disable:4589) // Constructor of abstract class 'Slice::Type' ignores initializer...
 #endif
 
 using namespace std;
 using namespace Slice;
 
+Slice::CompilerException::CompilerException(const char* file, int line, const string& r) :
+    IceUtil::Exception(file, line),
+    _reason(r)
+{
+}
+
+#ifndef ICE_CPP11_COMPILER
+Slice::CompilerException::~CompilerException() throw()
+{
+}
+#endif
+
+string
+Slice::CompilerException::ice_id() const
+{
+    return "::Slice::CompilerException";
+}
+
+void
+Slice::CompilerException::ice_print(ostream& out) const
+{
+    IceUtil::Exception::ice_print(out);
+    out << ": " << _reason;
+}
+
+#ifndef ICE_CPP11_MAPPING
+Slice::CompilerException*
+Slice::CompilerException::ice_clone() const
+{
+    return new CompilerException(*this);
+}
+#endif
+
+void
+Slice::CompilerException::ice_throw() const
+{
+    throw *this;
+}
+
+string
+Slice::CompilerException::reason() const
+{
+    return _reason;
+}
+
 extern FILE* slice_in;
 extern int slice_debug;
 
+int slice_parse();
+
 //
 // Operation attributes
 //
@@ -63,6 +106,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& unt, const TypePtr& type)
+{
+    ClassDeclPtr decl = ClassDeclPtr::dynamicCast(type);
+    if(decl && !decl->isLocal() && decl->isInterface())
+    {
+        unt->warning(Deprecated, "interface by value is deprecated");
+    }
+
+    ProxyPtr proxy = ProxyPtr::dynamicCast(type);
+    if(proxy && !proxy->_class()->isInterface())
+    {
+        unt->warning(Deprecated, "proxy for a class is deprecated");
+    }
+}
+
 }
 
 namespace Slice
@@ -79,6 +188,7 @@ Unit* unit;
 Slice::DefinitionContext::DefinitionContext(int includeLevel, const StringList& metaData) :
     _includeLevel(includeLevel), _metaData(metaData), _seenDefinition(false)
 {
+    initSuppressedWarnings();
 }
 
 string
@@ -121,6 +231,7 @@ void
 Slice::DefinitionContext::setMetaData(const StringList& metaData)
 {
     _metaData = metaData;
+    initSuppressedWarnings();
 }
 
 string
@@ -143,6 +254,144 @@ 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);
+    }
+}
+
+void
+Slice::DefinitionContext::error(const string& file, int line, const string& msg) const
+{
+    emitError(file, line, msg);
+    throw CompilerException(__FILE__, __LINE__, msg);
+}
+
+void
+Slice::DefinitionContext::error(const string& file, const string& line, const string& msg) const
+{
+    emitError(file, line, msg);
+    throw CompilerException(__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");
+                }
+            }
+        }
+    }
+}
+
+// ----------------------------------------------------------------------
+// Comment
+// ----------------------------------------------------------------------
+
+bool
+Slice::Comment::isDeprecated() const
+{
+    return _isDeprecated;
+}
+
+StringList
+Slice::Comment::deprecated() const
+{
+    return _deprecated;
+}
+
+StringList
+Slice::Comment::overview() const
+{
+    return _overview;
+}
+
+StringList
+Slice::Comment::misc() const
+{
+    return _misc;
+}
+
+StringList
+Slice::Comment::seeAlso() const
+{
+    return _seeAlso;
+}
+
+StringList
+Slice::Comment::returns() const
+{
+    return _returns;
+}
+
+map<string, StringList>
+Slice::Comment::parameters() const
+{
+    return _parameters;
+}
+
+map<string, StringList>
+Slice::Comment::exceptions() const
+{
+    return _exceptions;
+}
+
+Slice::Comment::Comment()
+{
+}
+
 // ----------------------------------------------------------------------
 // SyntaxTreeBase
 // ----------------------------------------------------------------------
@@ -170,12 +419,13 @@ Slice::SyntaxTreeBase::visit(ParserVisitor*, bool)
 {
 }
 
-Slice::SyntaxTreeBase::SyntaxTreeBase(const UnitPtr& unit) :
-    _unit(unit)
+Slice::SyntaxTreeBase::SyntaxTreeBase(const UnitPtr& unt, const DefinitionContextPtr& definitionContext) :
+    _unit(unt),
+    _definitionContext(definitionContext)
 {
-    if(_unit)
+    if(!_definitionContext && _unit)
     {
-        _definitionContext = unit->currentDefinitionContext();
+        _definitionContext = unt->currentDefinitionContext();
     }
 }
 
@@ -183,8 +433,8 @@ Slice::SyntaxTreeBase::SyntaxTreeBase(const UnitPtr& unit) :
 // Type
 // ----------------------------------------------------------------------
 
-Slice::Type::Type(const UnitPtr& unit) :
-    SyntaxTreeBase(unit)
+Slice::Type::Type(const UnitPtr& unt) :
+    SyntaxTreeBase(unt)
 {
 }
 
@@ -258,6 +508,11 @@ Slice::Builtin::typeId() const
             return "::Ice::LocalObject";
             break;
         }
+        case KindValue:
+        {
+            return "::Ice::Value";
+            break;
+        }
     }
     assert(false);
     return ""; // Keep the compiler happy.
@@ -266,7 +521,7 @@ Slice::Builtin::typeId() const
 bool
 Slice::Builtin::usesClasses() const
 {
-    return _kind == KindObject;
+    return _kind == KindObject || _kind == KindValue;
 }
 
 size_t
@@ -283,7 +538,9 @@ 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.
+        0, // KindLocalObject: unused
+        1  // KindValue: at least one byte (to marshal an index instead of an instance).
     };
 
     assert(_kind != KindLocalObject);
@@ -293,7 +550,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,12 +577,13 @@ const char* Slice::Builtin::builtinTable[] =
         "string",
         "Object",
         "Object*",
-        "LocalObject"
+        "LocalObject",
+        "Value"
     };
 
-Slice::Builtin::Builtin(const UnitPtr& unit, Kind kind) :
-    SyntaxTreeBase(unit),
-    Type(unit),
+Slice::Builtin::Builtin(const UnitPtr& ut, Kind kind) :
+    SyntaxTreeBase(ut),
+    Type(ut),
     _kind(kind)
 {
     //
@@ -368,12 +626,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
@@ -394,6 +653,330 @@ Slice::Contained::comment() const
     return _comment;
 }
 
+namespace
+{
+
+void
+trimLines(StringList& l)
+{
+    //
+    // Remove empty trailing lines.
+    //
+    while(!l.empty() && l.back().empty())
+    {
+        l.pop_back();
+    }
+}
+
+StringList
+splitComment(const string& c, bool stripMarkup)
+{
+    string comment = c;
+
+    if(stripMarkup)
+    {
+        //
+        // Strip HTML markup and javadoc links.
+        //
+        string::size_type pos = 0;
+        do
+        {
+            pos = comment.find('<', pos);
+            if(pos != string::npos)
+            {
+                string::size_type endpos = comment.find('>', pos);
+                if(endpos == string::npos)
+                {
+                    break;
+                }
+                comment.erase(pos, endpos - pos + 1);
+            }
+        }
+        while(pos != string::npos);
+
+        const string link = "{@link";
+        pos = 0;
+        do
+        {
+            pos = comment.find(link, pos);
+            if(pos != string::npos)
+            {
+                comment.erase(pos, link.size() + 1); // Erase trailing white space too.
+                string::size_type endpos = comment.find('}', pos);
+                if(endpos != string::npos)
+                {
+                    string ident = comment.substr(pos, endpos - pos);
+                    comment.erase(pos, endpos - pos + 1);
+
+                    //
+                    // Replace links of the form {@link Type#member} with "Type.member".
+                    //
+                    string::size_type hash = ident.find('#');
+                    string rest;
+                    if(hash != string::npos)
+                    {
+                        rest = ident.substr(hash + 1);
+                        ident = ident.substr(0, hash);
+                        if(!ident.empty())
+                        {
+                            if(!rest.empty())
+                            {
+                                ident += "." + rest;
+                            }
+                        }
+                        else if(!rest.empty())
+                        {
+                            ident = rest;
+                        }
+                    }
+
+                    comment.insert(pos, ident);
+                }
+            }
+        }
+        while(pos != string::npos);
+    }
+
+    StringList result;
+
+    string::size_type pos = 0;
+    string::size_type nextPos;
+    while((nextPos = comment.find_first_of('\n', pos)) != string::npos)
+    {
+        result.push_back(IceUtilInternal::trim(string(comment, pos, nextPos - pos)));
+        pos = nextPos + 1;
+    }
+    string lastLine = IceUtilInternal::trim(string(comment, pos));
+    if(!lastLine.empty())
+    {
+        result.push_back(lastLine);
+    }
+
+    trimLines(result);
+
+    return result;
+}
+
+bool
+parseCommentLine(const string& l, const string& tag, bool namedTag, string& name, string& doc)
+{
+    doc.clear();
+
+    if(l.find(tag) == 0)
+    {
+        const string ws = " \t";
+
+        if(namedTag)
+        {
+            string::size_type n = l.find_first_not_of(ws, tag.size());
+            if(n == string::npos)
+            {
+                return false; // Malformed line, ignore it.
+            }
+            string::size_type end = l.find_first_of(ws, n);
+            if(end == string::npos)
+            {
+                return false; // Malformed line, ignore it.
+            }
+            name = l.substr(n, end - n);
+            n = l.find_first_not_of(ws, end);
+            if(n != string::npos)
+            {
+                doc = l.substr(n);
+            }
+        }
+        else
+        {
+            name.clear();
+
+            string::size_type n = l.find_first_not_of(ws, tag.size());
+            if(n == string::npos)
+            {
+                return false; // Malformed line, ignore it.
+            }
+            doc = l.substr(n);
+        }
+
+        return true;
+    }
+
+    return false;
+}
+
+}
+
+CommentPtr
+Slice::Contained::parseComment(bool stripMarkup) const
+{
+    CommentPtr comment = new Comment;
+
+    comment->_isDeprecated = false;
+
+    //
+    // First check metadata for a deprecated tag.
+    //
+    string deprecateMetadata;
+    if(findMetaData("deprecate", deprecateMetadata))
+    {
+        comment->_isDeprecated = true;
+        if(deprecateMetadata.find("deprecate:") == 0 && deprecateMetadata.size() > 10)
+        {
+            comment->_deprecated.push_back(IceUtilInternal::trim(deprecateMetadata.substr(10)));
+        }
+    }
+
+    if(!comment->_isDeprecated && _comment.empty())
+    {
+        return 0;
+    }
+
+    //
+    // Split up the comment into lines.
+    //
+    StringList lines = splitComment(_comment, stripMarkup);
+
+    StringList::const_iterator i;
+    for(i = lines.begin(); i != lines.end(); ++i)
+    {
+        const string l = *i;
+        if(l[0] == '@')
+        {
+            break;
+        }
+        comment->_overview.push_back(l);
+    }
+
+    enum State { StateMisc, StateParam, StateThrows, StateReturn, StateDeprecated };
+    State state = StateMisc;
+    string name;
+    const string ws = " \t";
+    const string paramTag = "@param";
+    const string throwsTag = "@throws";
+    const string exceptionTag = "@exception";
+    const string returnTag = "@return";
+    const string deprecatedTag = "@deprecated";
+    const string seeTag = "@see";
+    for(; i != lines.end(); ++i)
+    {
+        const string l = IceUtilInternal::trim(*i);
+        string line;
+        if(parseCommentLine(l, paramTag, true, name, line))
+        {
+            if(!line.empty())
+            {
+                state = StateParam;
+                StringList sl;
+                sl.push_back(line); // The first line of the description.
+                comment->_parameters[name] = sl;
+            }
+        }
+        else if(parseCommentLine(l, throwsTag, true, name, line))
+        {
+            if(!line.empty())
+            {
+                state = StateThrows;
+                StringList sl;
+                sl.push_back(line); // The first line of the description.
+                comment->_exceptions[name] = sl;
+            }
+        }
+        else if(parseCommentLine(l, exceptionTag, true, name, line))
+        {
+            if(!line.empty())
+            {
+                state = StateThrows;
+                StringList sl;
+                sl.push_back(line); // The first line of the description.
+                comment->_exceptions[name] = sl;
+            }
+        }
+        else if(parseCommentLine(l, seeTag, false, name, line))
+        {
+            if(!line.empty())
+            {
+                comment->_seeAlso.push_back(line);
+            }
+        }
+        else if(parseCommentLine(l, returnTag, false, name, line))
+        {
+            if(!line.empty())
+            {
+                state = StateReturn;
+                comment->_returns.push_back(line); // The first line of the description.
+            }
+        }
+        else if(parseCommentLine(l, deprecatedTag, false, name, line))
+        {
+            comment->_isDeprecated = true;
+            if(!line.empty())
+            {
+                state = StateDeprecated;
+                comment->_deprecated.push_back(line); // The first line of the description.
+            }
+        }
+        else if(!l.empty())
+        {
+            if(l[0] == '@')
+            {
+                //
+                // Treat all other tags as miscellaneous comments.
+                //
+                state = StateMisc;
+            }
+
+            switch(state)
+            {
+                case StateMisc:
+                {
+                    comment->_misc.push_back(l);
+                    break;
+                }
+                case StateParam:
+                {
+                    assert(!name.empty());
+                    StringList sl;
+                    if(comment->_parameters.find(name) != comment->_parameters.end())
+                    {
+                        sl = comment->_parameters[name];
+                    }
+                    sl.push_back(l);
+                    comment->_parameters[name] = sl;
+                    break;
+                }
+                case StateThrows:
+                {
+                    assert(!name.empty());
+                    StringList sl;
+                    if(comment->_exceptions.find(name) != comment->_exceptions.end())
+                    {
+                        sl = comment->_exceptions[name];
+                    }
+                    sl.push_back(l);
+                    comment->_exceptions[name] = sl;
+                    break;
+                }
+                case StateReturn:
+                {
+                    comment->_returns.push_back(l);
+                    break;
+                }
+                case StateDeprecated:
+                {
+                    comment->_deprecated.push_back(l);
+                    break;
+                }
+            }
+        }
+    }
+
+    trimLines(comment->_overview);
+    trimLines(comment->_deprecated);
+    trimLines(comment->_misc);
+    trimLines(comment->_returns);
+
+    return comment;
+}
+
 int
 Slice::Contained::includeLevel() const
 {
@@ -496,12 +1079,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),
@@ -539,7 +1116,6 @@ Slice::Container::destroy()
 ModulePtr
 Slice::Container::createModule(const string& name)
 {
-    checkIdentifier(name);
     ContainedList matches = _unit->findContents(thisScope() + name);
     matches.sort(); // Modules can occur many times...
     matches.unique(); // ... but we only want one instance of each.
@@ -592,8 +1168,6 @@ Slice::Container::createModule(const string& name)
 ClassDefPtr
 Slice::Container::createClassDef(const string& name, int id, bool intf, const ClassList& bases, bool local)
 {
-    checkIdentifier(name);
-
     ContainedList matches = _unit->findContents(thisScope() + name);
     for(ContainedList::const_iterator p = matches.begin(); p != matches.end(); ++p)
     {
@@ -674,20 +1248,15 @@ Slice::Container::createClassDef(const string& name, int id, bool intf, const Cl
     // definition. This way the code generator can rely on always
     // having a class declaration available for lookup.
     //
-    ClassDeclPtr decl = createClassDecl(name, intf, local, false);
+    ClassDeclPtr decl = createClassDecl(name, intf, local);
     def->_declaration = decl;
 
     return def;
 }
 
 ClassDeclPtr
-Slice::Container::createClassDecl(const string& name, bool intf, bool local, bool checkName)
+Slice::Container::createClassDecl(const string& name, bool intf, bool local)
 {
-    if (checkName)
-    {
-        checkIdentifier(name);
-    }
-
     ClassDefPtr def;
 
     ContainedList matches = _unit->findContents(thisScope() + name);
@@ -777,8 +1346,6 @@ Slice::Container::createClassDecl(const string& name, bool intf, bool local, boo
 ExceptionPtr
 Slice::Container::createException(const string& name, const ExceptionPtr& base, bool local, NodeType nt)
 {
-    checkIdentifier(name);
-
     ContainedList matches = _unit->findContents(thisScope() + name);
     if(!matches.empty())
     {
@@ -829,8 +1396,6 @@ Slice::Container::createException(const string& name, const ExceptionPtr& base,
 StructPtr
 Slice::Container::createStruct(const string& name, bool local, NodeType nt)
 {
-    checkIdentifier(name);
-
     ContainedList matches = _unit->findContents(thisScope() + name);
     if(!matches.empty())
     {
@@ -874,19 +1439,6 @@ SequencePtr
 Slice::Container::createSequence(const string& name, const TypePtr& type, const StringList& metaData, bool local,
                                  NodeType nt)
 {
-    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 +1482,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;
@@ -940,19 +1494,6 @@ Slice::Container::createDictionary(const string& name, const TypePtr& keyType, c
                                    const TypePtr& valueType, const StringList& valueMetaData, bool local,
                                    NodeType nt)
 {
-    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 +1538,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 +1556,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;
@@ -1023,8 +1566,6 @@ Slice::Container::createDictionary(const string& name, const TypePtr& keyType, c
 EnumPtr
 Slice::Container::createEnum(const string& name, bool local, NodeType nt)
 {
-    checkIdentifier(name);
-
     ContainedList matches = _unit->findContents(thisScope() + name);
     if(!matches.empty())
     {
@@ -1068,13 +1609,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 +1621,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;
 }
 
@@ -1097,8 +1634,6 @@ Slice::Container::createConst(const string name, const TypePtr& constType, const
                               const SyntaxTreeBasePtr& valueType, const string& value, const string& literal,
                               NodeType nt)
 {
-    checkIdentifier(name);
-
     ContainedList matches = _unit->findContents(thisScope() + name);
     if(!matches.empty())
     {
@@ -1133,15 +1668,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;
 }
@@ -1174,20 +1711,12 @@ Slice::Container::lookupType(const string& scoped, bool printError)
 
     //
     // Not a builtin type, try to look up a constructed type.
-    //
-    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;
+    //
+    return lookupTypeNoBuiltin(scoped, printError);
 }
 
 TypeList
-Slice::Container::lookupTypeNoBuiltin(const string& scoped, bool printError)
+Slice::Container::lookupTypeNoBuiltin(const string& scoped, bool printError, bool ignoreUndefined)
 {
     //
     // Remove whitespace.
@@ -1304,12 +1833,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 +1957,6 @@ Slice::Container::unit() const
     return SyntaxTreeBase::unit();
 }
 
-
 ModuleList
 Slice::Container::modules() const
 {
@@ -1539,6 +2062,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 cl2 = (*p)->lookupContained(name, false);
+                    if(!cl2.empty())
+                    {
+                        result.push_back(EnumeratorPtr::dynamicCast(cl2.front()));
+                    }
+                }
+            }
+        }
+    }
+
+    return result;
+}
+
 ConstList
 Slice::Container::consts() const
 {
@@ -1610,7 +2213,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 +2221,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 +2280,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 +2417,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
 {
@@ -1797,18 +2500,39 @@ Slice::Container::hasOnlyClassDecls() const
 }
 
 bool
-Slice::Container::hasAbstractClassDefs() const
+Slice::Container::hasOperations() const
+{
+    for(ContainedList::const_iterator p = _contents.begin(); p != _contents.end(); ++p)
+    {
+        ClassDefPtr cl = ClassDefPtr::dynamicCast(*p);
+        if(cl && cl->hasOperations())
+        {
+            return true;
+        }
+
+        ContainerPtr container = ContainerPtr::dynamicCast(*p);
+        if(container && container->hasOperations())
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool
+Slice::Container::hasNonLocalAbstractClassDefs() const
 {
     for(ContainedList::const_iterator p = _contents.begin(); p != _contents.end(); ++p)
     {
         ClassDefPtr cl = ClassDefPtr::dynamicCast(*p);
-        if(cl && cl->isAbstract())
+        if(cl && cl->isAbstract() && !cl->isLocal())
         {
             return true;
         }
 
         ContainerPtr container = ContainerPtr::dynamicCast(*p);
-        if(container && container->hasAbstractClassDefs())
+        if(container && container->hasNonLocalAbstractClassDefs())
         {
             return true;
         }
@@ -2001,7 +2725,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());
             }
 
@@ -2275,63 +2999,6 @@ Slice::Container::Container(const UnitPtr& unit) :
 {
 }
 
-void
-Slice::Container::checkIdentifier(const string& name) const
-{
-    //
-    // Weed out identifiers with reserved suffixes.
-    //
-    static const string suffixBlacklist[] = { "Helper", "Holder", "Prx", "Ptr" };
-    for(size_t i = 0; i < sizeof(suffixBlacklist) / sizeof(*suffixBlacklist); ++i)
-    {
-        if(name.find(suffixBlacklist[i], name.size() - suffixBlacklist[i].size()) != string::npos)
-        {
-            _unit->error("illegal identifier `" + name + "': `" + suffixBlacklist[i] + "' suffix is reserved");
-        }
-    }
-
-    //
-    // Check for illegal underscores.
-    //
-    if(name.find('_') == 0)
-    {
-        _unit->error("illegal leading underscore in identifier `" + name + "'");
-    }
-    else if(name.rfind('_') == name.size() - 1)
-    {
-        _unit->error("illegal trailing underscore in identifier `" + name + "'");
-    }
-    else if(name.find("__") != string::npos)
-    {
-        _unit->error("illegal double underscore in identifier `" + name + "'");
-    }
-    else if(_unit->currentIncludeLevel() == 0 && !_unit->allowUnderscore() && name.find('_') != string::npos)
-    {
-        //
-        // For rules controlled by a translator option, we don't complain about included files.
-        //
-        _unit->error("illegal underscore in identifier `" + name + "'");
-    }
-
-    if(_unit->currentIncludeLevel() == 0 && !_unit->allowIcePrefix())
-    {
-        //
-        // For rules controlled by a translator option, we don't complain about included files.
-        //
-        if(name.size() >= 3)
-        {
-            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");
-            }
-        }
-    }
-}
-
 bool
 Slice::Container::checkInterfaceAndLocal(const string& name, bool defined,
                                          bool intf, bool intfOther,
@@ -2429,7 +3096,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 +3242,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 +3325,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;
+                }
             }
         }
     }
@@ -2681,8 +3386,6 @@ Slice::Container::validateConstant(const string& name, const TypePtr& type, cons
 EnumeratorPtr
 Slice::Container::validateEnumerator(const string& name)
 {
-    checkIdentifier(name);
-
     ContainedList matches = _unit->findContents(thisScope() + name);
     if(!matches.empty())
     {
@@ -2697,20 +3400,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;
 }
 
@@ -2884,7 +3584,7 @@ Slice::ClassDecl::recDependencies(set& dependencies)
 
 void
 Slice::ClassDecl::checkBasesAreLegal(const string& name, bool intf, bool local, const ClassList& bases,
-                                     const UnitPtr& unit)
+                                     const UnitPtr& ut)
 {
     //
     // Local definitions cannot have non-local bases, and vice versa.
@@ -2897,7 +3597,7 @@ Slice::ClassDecl::checkBasesAreLegal(const string& name, bool intf, bool local,
             msg << (local ? "local" : "non-local") << " " << (intf ? "interface" : "class") << " `"
                 << name << "' cannot have " << ((*p)->isLocal() ? "local" : "non-local") << " base "
                 << ((*p)->isInterface() ? "interface" : "class") << " `" << (*p)->name() << "'";
-            unit->error(msg.str());
+            ut->error(msg.str());
         }
     }
 
@@ -2934,7 +3634,7 @@ Slice::ClassDecl::checkBasesAreLegal(const string& name, bool intf, bool local,
         // name (that is, if the union of the intersections of all possible pairs
         // of partitions is empty).
         //
-        checkPairIntersections(spl, name, unit);
+        checkPairIntersections(spl, name, ut);
     }
 }
 
@@ -3036,7 +3736,7 @@ Slice::ClassDecl::toStringPartitionList(const GraphPartitionList& gpl)
 // in the other and, if so, complain.
 //
 void
-Slice::ClassDecl::checkPairIntersections(const StringPartitionList& l, const string& name, const UnitPtr& unit)
+Slice::ClassDecl::checkPairIntersections(const StringPartitionList& l, const string& name, const UnitPtr& ut)
 {
     set<string> reported;
     for(StringPartitionList::const_iterator i = l.begin(); i != l.end(); ++i)
@@ -3053,7 +3753,7 @@ Slice::ClassDecl::checkPairIntersections(const StringPartitionList& l, const str
                     {
                         string msg = "ambiguous multiple inheritance: `" + name;
                         msg += "' inherits operation `" + *s1 + "' from two or more unrelated base interfaces";
-                        unit->error(msg);
+                        ut->error(msg);
                         reported.insert(*s1);
                     }
                     else if(!CICompare()(*s1, *s2) && !CICompare()(*s2, *s1) &&
@@ -3062,7 +3762,7 @@ Slice::ClassDecl::checkPairIntersections(const StringPartitionList& l, const str
                         string msg = "ambiguous multiple inheritance: `" + name;
                         msg += "' inherits operations `" + *s1 + "' and `" + *s2;
                         msg += "', which differ only in capitalization, from unrelated base interfaces";
-                        unit->error(msg);
+                        ut->error(msg);
                         reported.insert(*s1);
                         reported.insert(*s2);
                     }
@@ -3080,7 +3780,7 @@ void
 Slice::ClassDef::destroy()
 {
     _declaration = 0;
-    _bases.empty();
+    _bases.clear();
     Container::destroy();
 }
 
@@ -3091,8 +3791,6 @@ Slice::ClassDef::createOperation(const string& name,
                                  int tag,
                                  Operation::Mode mode)
 {
-    checkIdentifier(name);
-
     ContainedList matches = _unit->findContents(thisScope() + name);
     if(!matches.empty())
     {
@@ -3166,8 +3864,8 @@ Slice::ClassDef::createOperation(const string& name,
             }
 
             string baseName = IceUtilInternal::toLower((*q)->name());
-            string newName = IceUtilInternal::toLower(name);
-            if(baseName == newName)
+            string newName2 = IceUtilInternal::toLower(name);
+            if(baseName == newName2)
             {
                 string msg = "operation `" + name + "' differs only in capitalization from " + (*q)->kindOf();
                 msg += " `" + (*q)->name() + "', which is defined in a base interface or class";
@@ -3186,6 +3884,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);
@@ -3197,30 +3901,6 @@ Slice::ClassDef::createDataMember(const string& name, const TypePtr& type, bool
                                   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 = "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())
@@ -3280,8 +3960,8 @@ Slice::ClassDef::createDataMember(const string& name, const TypePtr& type, bool
             }
 
             string baseName = IceUtilInternal::toLower((*q)->name());
-            string newName = IceUtilInternal::toLower(name);
-            if(baseName == newName)
+            string newName2 = IceUtilInternal::toLower(name);
+            if(baseName == newName2)
             {
                 string msg = "data member `" + name + "' differs only in capitalization from " + (*q)->kindOf();
                 msg += " `" + (*q)->name() + "', which is defined in a base interface or class";
@@ -3303,7 +3983,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 +4016,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);
@@ -3387,14 +4069,26 @@ Slice::ClassDef::operations() const
 OperationList
 Slice::ClassDef::allOperations() const
 {
-    OperationList result = operations();
-    result.sort();
-    result.unique();
+    OperationList result;
     for(ClassList::const_iterator p = _bases.begin(); p != _bases.end(); ++p)
     {
         OperationList li = (*p)->allOperations();
-        result.merge(li);
-        result.unique();
+        for(OperationList::const_iterator q = li.begin(); q != li.end(); ++q)
+        {
+            if(find(result.begin(), result.end(), *q) == result.end())
+            {
+                result.push_back(*q);
+            }
+        }
+    }
+
+    OperationList li = operations();
+    for(OperationList::const_iterator q = li.begin(); q != li.end(); ++q)
+    {
+        if(find(result.begin(), result.end(), *q) == result.end())
+        {
+            result.push_back(*q);
+        }
     }
     return result;
 }
@@ -3456,7 +4150,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 +4299,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 +4352,12 @@ 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 +4370,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 +4405,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 +4435,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)
+    SyntaxTreeBase(cl->unit(), cl->definitionContext()),
+    Type(cl->unit()),
+    _classDecl(cl)
 {
 }
 
@@ -3737,30 +4461,6 @@ Slice::Exception::createDataMember(const string& name, const TypePtr& type, bool
                                    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 = "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())
     {
@@ -3807,8 +4507,8 @@ Slice::Exception::createDataMember(const string& name, const TypePtr& type, bool
             }
 
             string baseName = IceUtilInternal::toLower((*r)->name());
-            string newName = IceUtilInternal::toLower(name);
-            if(baseName == newName)
+            string newName2 = IceUtilInternal::toLower(name);
+            if(baseName == newName2)
             {
                 string msg = "exception member `" + name + "' differs only in capitalization from exception member `";
                 msg += (*r)->name() + "', which is defined in a base exception";
@@ -3830,7 +4530,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 +4563,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 +4627,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 +4763,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 +4803,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 +4854,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 +4887,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 +4919,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 +5260,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 +5322,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,13 +5393,75 @@ Slice::Enum::recDependencies(set&)
 
 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;
 }
 
 // ----------------------------------------------------------------------
@@ -4779,7 +5471,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 +5510,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 +5519,7 @@ Slice::Enumerator::Enumerator(const ContainerPtr& container, const string& name,
     _explicitValue(true),
     _value(value)
 {
+    EnumPtr::dynamicCast(container)->newEnumerator(this);
 }
 
 // ----------------------------------------------------------------------
@@ -4898,6 +5592,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,34 +5640,32 @@ 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)
+{
     ContainedList matches = _unit->findContents(thisScope() + name);
     if(!matches.empty())
     {
@@ -5023,6 +5720,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 +5769,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 +5988,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 +6046,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
         {
@@ -5277,14 +6060,14 @@ Slice::Operation::attributes() const
             //
             freezeMD = freezeMD.substr(1);
 
-            int i = 0;
+            i = 0;
             while(i < 4)
             {
                 if(freezeMD.find(txAttribute[i]) == 0)
                 {
                     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 +6081,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 +6139,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 +6567,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 +6575,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
@@ -5997,7 +6758,7 @@ Slice::Unit::addTypeId(int compactId, const std::string& typeId)
 }
 
 std::string
-Slice::Unit::getTypeId(int compactId)
+Slice::Unit::getTypeId(int compactId) const
 {
     map<int, string>::const_iterator p = _typeIds.find(compactId);
     if(p != _typeIds.end())
@@ -6007,6 +6768,12 @@ Slice::Unit::getTypeId(int compactId)
     return string();
 }
 
+bool
+Slice::Unit::hasCompactTypeId() const
+{
+    return _typeIds.size() > 0;
+}
+
 bool
 Slice::Unit::usesNonLocals() const
 {
@@ -6038,6 +6805,11 @@ Slice::Unit::usesNonLocals() const
         return true;
     }
 
+    if(_builtins.find(Builtin::KindValue) != _builtins.end())
+    {
+        return true;
+    }
+
     return false;
 }
 
@@ -6059,12 +6831,6 @@ Slice::Unit::usesConsts() const
     return false;
 }
 
-FeatureProfile
-Slice::Unit::profile() const
-{
-    return _featureProfile;
-}
-
 StringList
 Slice::Unit::includeFiles() const
 {
@@ -6084,7 +6850,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 +6860,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();
@@ -6270,7 +7035,6 @@ Slice::cICompare(const std::string& s1, const std::string& s2)
 }
 #endif
 
-
 // ----------------------------------------------------------------------
 // DerivedToBaseCompare
 // ----------------------------------------------------------------------