Typescript support

1 files changed, 1449 insertions, 156 deletions

diff --git a/cpp/src/slice2js/Gen.cpp b/cpp/src/slice2js/Gen.cpp
index 7a4e61f3115..be159aa206b 100644
--- a/cpp/src/slice2js/Gen.cpp
+++ b/cpp/src/slice2js/Gen.cpp
@@ -11,19 +11,11 @@
 #include <IceUtil/StringUtil.h>
 #include <IceUtil/InputUtil.h>
 #include <Gen.h>
-#include <limits>
-#include <sys/stat.h>
-#ifndef _WIN32
-#include <unistd.h>
-#else
-#include <direct.h>
-#endif
 #include <IceUtil/Iterator.h>
 #include <IceUtil/UUID.h>
 #include <Slice/Checksum.h>
 #include <Slice/FileTracker.h>
 #include <Slice/Util.h>
-#include <string.h>
 
 using namespace std;
 using namespace Slice;
@@ -86,9 +78,289 @@ getDeprecateReason(const ContainedPtr& p1, const ContainedPtr& p2, const string&
     return deprecateReason;
 }
 
+void
+printHeader(IceUtilInternal::Output& out)
+{
+    static const char* header =
+        "// **********************************************************************\n"
+        "//\n"
+        "// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.\n"
+        "//\n"
+        "// This copy of Ice is licensed to you under the terms described in the\n"
+        "// ICE_LICENSE file included in this distribution.\n"
+        "//\n"
+        "// **********************************************************************\n"
+        ;
+
+    out << header;
+    out << "//\n";
+    out << "// Ice version " << ICE_STRING_VERSION << "\n";
+    out << "//\n";
+}
+
+string
+escapeParam(const ParamDeclList& params, const string& name)
+{
+    string r = name;
+    for(ParamDeclList::const_iterator p = params.begin(); p != params.end(); ++p)
+    {
+        if(Slice::JsGenerator::fixId((*p)->name()) == name)
+        {
+            r = name + "_";
+            break;
+        }
+    }
+    return r;
+}
+
+void
+writeDocLines(Output& out, const StringList& lines, bool commentFirst, const string& space = " ")
+{
+    StringList l = lines;
+    if(!commentFirst)
+    {
+        out << l.front();
+        l.pop_front();
+    }
+    for(StringList::const_iterator i = l.begin(); i != l.end(); ++i)
+    {
+        out << nl << " *";
+        if(!i->empty())
+        {
+            out << space << *i;
+        }
+    }
+}
+
+void
+writeSeeAlso(Output& out, const StringList& lines, const string& space = " ")
+{
+    for(StringList::const_iterator i = lines.begin(); i != lines.end(); ++i)
+    {
+        out << nl << " *";
+        if(!i->empty())
+        {
+            out << space << "@see " << *i;
+        }
+    }
+}
+
+string
+getDocSentence(const StringList& lines)
+{
+    //
+    // Extract the first sentence.
+    //
+    ostringstream ostr;
+    for(StringList::const_iterator i = lines.begin(); i != lines.end(); ++i)
+    {
+        const string ws = " \t";
+
+        if(i->empty())
+        {
+            break;
+        }
+        if(i != lines.begin() && i->find_first_not_of(ws) == 0)
+        {
+            ostr << " ";
+        }
+        string::size_type pos = i->find('.');
+        if(pos == string::npos)
+        {
+            ostr << *i;
+        }
+        else if(pos == i->size() - 1)
+        {
+            ostr << *i;
+            break;
+        }
+        else
+        {
+            //
+            // Assume a period followed by whitespace indicates the end of the sentence.
+            //
+            while(pos != string::npos)
+            {
+                if(ws.find((*i)[pos + 1]) != string::npos)
+                {
+                    break;
+                }
+                pos = i->find('.', pos + 1);
+            }
+            if(pos != string::npos)
+            {
+                ostr << i->substr(0, pos + 1);
+                break;
+            }
+            else
+            {
+                ostr << *i;
+            }
+        }
+    }
+
+    return ostr.str();
+}
+
+void
+writeDocSummary(Output& out, const ContainedPtr& p)
+{
+    if(p->comment().empty())
+    {
+        return;
+    }
+
+    CommentPtr doc = p->parseComment(false);
+
+    out << nl << "/**";
+
+    if(!doc->overview().empty())
+    {
+        writeDocLines(out, doc->overview(), true);
+    }
+
+    if(!doc->misc().empty())
+    {
+        writeDocLines(out, doc->misc(), true);
+    }
+
+    if(!doc->seeAlso().empty())
+    {
+        writeSeeAlso(out, doc->seeAlso());
+    }
+
+    if(!doc->deprecated().empty())
+    {
+        out << nl << " *";
+        out << nl << " * @deprecated ";
+        writeDocLines(out, doc->deprecated(), false);
+    }
+    else if(doc->isDeprecated())
+    {
+        out << nl << " *";
+        out << nl << " * @deprecated";
+    }
+
+    out << nl << " */";
+}
+
+enum OpDocParamType { OpDocInParams, OpDocOutParams, OpDocAllParams };
+
+void
+writeOpDocParams(Output& out, const OperationPtr& op, const CommentPtr& doc, OpDocParamType type,
+                 const StringList& preParams = StringList(), const StringList& postParams = StringList())
+{
+    ParamDeclList params;
+    switch (type)
+    {
+    case OpDocInParams:
+        params = op->inParameters();
+        break;
+    case OpDocOutParams:
+        params = op->outParameters();
+        break;
+    case OpDocAllParams:
+        params = op->parameters();
+        break;
+    }
+
+    if (!preParams.empty())
+    {
+        writeDocLines(out, preParams, true);
+    }
+
+    map<string, StringList> paramDoc = doc->parameters();
+    for (ParamDeclList::iterator p = params.begin(); p != params.end(); ++p)
+    {
+        map<string, StringList>::iterator q = paramDoc.find((*p)->name());
+        if(q != paramDoc.end())
+        {
+            out << nl << " * @param " << Slice::JsGenerator::fixId(q->first) << " ";
+            writeDocLines(out, q->second, false);
+        }
+    }
+
+    if(!postParams.empty())
+    {
+        writeDocLines(out, postParams, true);
+    }
+}
+
+void
+writeOpDocExceptions(Output& out, const OperationPtr& op, const CommentPtr& doc)
+{
+    map<string, StringList> exDoc = doc->exceptions();
+    for (map<string, StringList>::iterator p = exDoc.begin(); p != exDoc.end(); ++p)
+    {
+        //
+        // Try to locate the exception's definition using the name given in the comment.
+        //
+        string name = p->first;
+        ExceptionPtr ex = op->container()->lookupException(name, false);
+        if (ex)
+        {
+            name = ex->scoped().substr(2);
+        }
+        out << nl << " * @throws " << name << " ";
+        writeDocLines(out, p->second, false);
+    }
 }
 
-Slice::JsVisitor::JsVisitor(Output& out) : _out(out)
+void
+writeOpDocSummary(Output& out, const OperationPtr& op, const CommentPtr& doc, OpDocParamType type, bool showExceptions,
+                  const StringList& preParams = StringList(), const StringList& postParams = StringList(),
+                  const StringList& returns = StringList())
+{
+    out << nl << "/**";
+
+    if (!doc->overview().empty())
+    {
+        writeDocLines(out, doc->overview(), true);
+    }
+
+    writeOpDocParams(out, op, doc, type, preParams, postParams);
+
+    if(!returns.empty())
+    {
+        out << nl << " * @return ";
+        writeDocLines(out, returns, false);
+    }
+
+    if(showExceptions)
+    {
+        writeOpDocExceptions(out, op, doc);
+    }
+
+    if(!doc->misc().empty())
+    {
+        writeDocLines(out, doc->misc(), true);
+    }
+
+    if(!doc->seeAlso().empty())
+    {
+        writeSeeAlso(out, doc->seeAlso());
+    }
+
+    if(!doc->deprecated().empty())
+    {
+        out << nl << " *";
+        out << nl << " * @deprecated ";
+        writeDocLines(out, doc->deprecated(), false);
+    }
+    else if(doc->isDeprecated())
+    {
+        out << nl << " *";
+        out << nl << " * @deprecated";
+    }
+
+    out << nl << " */";
+}
+
+}
+
+Slice::JsVisitor::JsVisitor(Output& out, const vector<pair<string, string>>& imports) :
+    _out(out),
+    _imports(imports)
 {
 }
 
@@ -96,6 +368,12 @@ Slice::JsVisitor::~JsVisitor()
 {
 }
 
+vector<pair<string, string>>
+Slice::JsVisitor::imports() const
+{
+    return _imports;
+}
+
 void
 Slice::JsVisitor::writeMarshalDataMembers(const DataMemberList& dataMembers, const DataMemberList& optionalMembers)
 {
@@ -131,7 +409,7 @@ Slice::JsVisitor::writeUnmarshalDataMembers(const DataMemberList& dataMembers, c
 }
 
 void
-Slice::JsVisitor::writeInitDataMembers(const DataMemberList& dataMembers, const string& scope)
+Slice::JsVisitor::writeInitDataMembers(const DataMemberList& dataMembers)
 {
     for(DataMemberList::const_iterator q = dataMembers.begin(); q != dataMembers.end(); ++q)
     {
@@ -188,7 +466,7 @@ Slice::JsVisitor::getValue(const string& scope, const TypePtr& type)
     EnumPtr en = EnumPtr::dynamicCast(type);
     if(en)
     {
-        return getReference(scope, en->scoped()) + '.' + fixId((*en->enumerators().begin())->name());
+        return fixId(en->scoped()) + '.' + fixId((*en->enumerators().begin())->name());
     }
 
     StructPtr st = StructPtr::dynamicCast(type);
@@ -208,7 +486,7 @@ Slice::JsVisitor::writeConstantValue(const string& scope, const TypePtr& type, c
     ConstPtr constant = ConstPtr::dynamicCast(valueType);
     if(constant)
     {
-        os << getReference(scope, constant->scoped());
+        os << fixId(constant->scoped());
     }
     else
     {
@@ -243,7 +521,7 @@ Slice::JsVisitor::writeConstantValue(const string& scope, const TypePtr& type, c
         {
             EnumeratorPtr lte = EnumeratorPtr::dynamicCast(valueType);
             assert(lte);
-            os << getReference(scope, ep->scoped()) << '.' << fixId(lte->name());
+            os << fixId(ep->scoped()) << '.' << fixId(lte->name());
         }
         else
         {
@@ -331,18 +609,20 @@ Slice::JsVisitor::writeDocComment(const ContainedPtr& p, const string& deprecate
     _out << nl << " **/";
 }
 
-Slice::Gen::Gen(const string& base, const vector<string>& includePaths, const string& dir) :
+Slice::Gen::Gen(const string& base, const vector<string>& includePaths, const string& dir, bool typeScript) :
     _includePaths(includePaths),
-    _useStdout(false)
+    _useStdout(false),
+    _typeScript(typeScript)
 {
     _fileBase = base;
+
     string::size_type pos = base.find_last_of("/\\");
     if(pos != string::npos)
     {
         _fileBase = base.substr(pos + 1);
     }
 
-    string file = _fileBase + ".js";
+    string file = _fileBase + (typeScript ? ".d.ts" : ".js");
 
     if(!dir.empty())
     {
@@ -358,14 +638,16 @@ Slice::Gen::Gen(const string& base, const vector<string>& includePaths, const st
     }
     FileTracker::instance()->addFile(file);
 
-    printHeader();
+    printHeader(_out);
     printGeneratedHeader(_out, _fileBase + ".ice");
 }
 
-Slice::Gen::Gen(const string& base, const vector<string>& includePaths, const string& dir, ostream& out) :
+Slice::Gen::Gen(const string& base, const vector<string>& includePaths, const string& dir, bool typeScript,
+                ostream& out) :
     _out(out),
     _includePaths(includePaths),
-    _useStdout(true)
+    _useStdout(true),
+    _typeScript(typeScript)
 {
     _fileBase = base;
     string::size_type pos = base.find_last_of("/\\");
@@ -374,7 +656,7 @@ Slice::Gen::Gen(const string& base, const vector<string>& includePaths, const st
         _fileBase = base.substr(pos + 1);
     }
 
-    printHeader();
+    printHeader(_out);
     printGeneratedHeader(_out, _fileBase + ".ice");
 }
 
@@ -390,70 +672,106 @@ void
 Slice::Gen::generate(const UnitPtr& p)
 {
     //
-    // Check for global "js:ice-build" and "js:es6-module"
-    // metadata. If this is set then we are building Ice.
+    // Check for "js:module:ice" metadata. If this
+    // is set then we are building Ice.
+    //
+    ModuleList modules = p->modules();
+    bool icejs = false;
+    for(ModuleList::const_iterator i = modules.begin(); i != modules.end(); i++)
+    {
+        if(p->topLevelFile() == (*i)->definitionContext()->filename() &&
+           getModuleMetadata(ContainedPtr::dynamicCast(*i)) == "ice")
+        {
+            icejs = true;
+            break;
+        }
+    }
+
+    //
+    // Check for global "js:es6-module" metadata.
     //
     DefinitionContextPtr dc = p->findDefinitionContext(p->topLevelFile());
     assert(dc);
     StringList globalMetaData = dc->getMetaData();
-    bool icejs = find(globalMetaData.begin(), globalMetaData.end(), "js:ice-build") != globalMetaData.end();
     bool es6module = find(globalMetaData.begin(), globalMetaData.end(), "js:es6-module") != globalMetaData.end();
 
-    _out << nl << "/* eslint-disable */";
-    _out << nl << "/* jshint ignore: start */";
-    _out << nl;
+    if(_typeScript)
+    {
+        TypeScriptRequireVisitor requireVisitor(_out);
+        p->visit(&requireVisitor, false);
+        requireVisitor.writeRequires(p);
+
+        //
+        // If at some point TypeScript adds an operator to refer to a type in the global scope
+        // we can get rid of the TypeScriptAliasVisitor and use this. For now we need to generate
+        // a type alias when there is an abiguity.
+        // see: https://github.com/Microsoft/TypeScript/issues/983
+        //
+        TypeScriptAliasVisitor aliasVisitor(_out);
+        p->visit(&aliasVisitor, false);
+        aliasVisitor.writeAlias(p);
 
-    if(!es6module)
+        TypeScriptVisitor typeScriptVisitor(_out, requireVisitor.imports());
+        p->visit(&typeScriptVisitor, false);
+    }
+    else
     {
-        if(icejs)
-        {
-            _out.zeroIndent();
-            _out << nl << "/* slice2js browser-bundle-skip */";
-            _out.restoreIndent();
-        }
-        _out << nl << "(function(module, require, exports)";
-        _out << sb;
-        if(icejs)
+        _out << nl << "/* eslint-disable */";
+        _out << nl << "/* jshint ignore: start */";
+        _out << nl;
+
+        if(!es6module)
         {
-            _out.zeroIndent();
-            _out << nl << "/* slice2js browser-bundle-skip-end */";
-            _out.restoreIndent();
+            if(icejs)
+            {
+                _out.zeroIndent();
+                _out << nl << "/* slice2js browser-bundle-skip */";
+                _out.restoreIndent();
+            }
+            _out << nl << "(function(module, require, exports)";
+            _out << sb;
+            if(icejs)
+            {
+                _out.zeroIndent();
+                _out << nl << "/* slice2js browser-bundle-skip-end */";
+                _out.restoreIndent();
+            }
         }
-    }
-    RequireVisitor requireVisitor(_out, _includePaths, icejs, es6module);
-    p->visit(&requireVisitor, false);
-    vector<string> seenModules = requireVisitor.writeRequires(p);
+        RequireVisitor requireVisitor(_out, _includePaths, icejs, es6module);
+        p->visit(&requireVisitor, false);
+        vector<string> seenModules = requireVisitor.writeRequires(p);
 
-    TypesVisitor typesVisitor(_out, seenModules, icejs);
-    p->visit(&typesVisitor, false);
+        TypesVisitor typesVisitor(_out, seenModules, icejs);
+        p->visit(&typesVisitor, false);
 
-    //
-    // Export the top-level modules.
-    //
-    ExportVisitor exportVisitor(_out, icejs, es6module);
-    p->visit(&exportVisitor, false);
+        //
+        // Export the top-level modules.
+        //
+        ExportVisitor exportVisitor(_out, icejs, es6module);
+        p->visit(&exportVisitor, false);
 
-    if(!es6module)
-    {
-        if(icejs)
+        if(!es6module)
         {
-            _out.zeroIndent();
-            _out << nl << "/* slice2js browser-bundle-skip */";
-            _out.restoreIndent();
-        }
+            if(icejs)
+            {
+                _out.zeroIndent();
+                _out << nl << "/* slice2js browser-bundle-skip */";
+                _out.restoreIndent();
+            }
 
-        _out << eb;
-        _out << nl << "(typeof(global) !== \"undefined\" && typeof(global.process) !== \"undefined\" ? module : undefined,"
-             << nl << " typeof(global) !== \"undefined\" && typeof(global.process) !== \"undefined\" ? require :"
-             << nl << " (typeof WorkerGlobalScope !== \"undefined\" && self instanceof WorkerGlobalScope) ? self.Ice._require : window.Ice._require,"
-             << nl << " typeof(global) !== \"undefined\" && typeof(global.process) !== \"undefined\" ? exports :"
-             << nl << " (typeof WorkerGlobalScope !== \"undefined\" && self instanceof WorkerGlobalScope) ? self : window));";
+            _out << eb;
+            _out << nl << "(typeof(global) !== \"undefined\" && typeof(global.process) !== \"undefined\" ? module : undefined,"
+                 << nl << " typeof(global) !== \"undefined\" && typeof(global.process) !== \"undefined\" ? require :"
+                 << nl << " (typeof WorkerGlobalScope !== \"undefined\" && self instanceof WorkerGlobalScope) ? self.Ice._require : window.Ice._require,"
+                 << nl << " typeof(global) !== \"undefined\" && typeof(global.process) !== \"undefined\" ? exports :"
+                 << nl << " (typeof WorkerGlobalScope !== \"undefined\" && self instanceof WorkerGlobalScope) ? self : window));";
 
-        if(icejs)
-        {
-            _out.zeroIndent();
-            _out << nl << "/* slice2js browser-bundle-skip-end */";
-            _out.restoreIndent();
+            if(icejs)
+            {
+                _out.zeroIndent();
+                _out << nl << "/* slice2js browser-bundle-skip-end */";
+                _out.restoreIndent();
+            }
         }
     }
 }
@@ -464,26 +782,6 @@ Slice::Gen::closeOutput()
     _out.close();
 }
 
-void
-Slice::Gen::printHeader()
-{
-    static const char* header =
-"// **********************************************************************\n"
-"//\n"
-"// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.\n"
-"//\n"
-"// This copy of Ice is licensed to you under the terms described in the\n"
-"// ICE_LICENSE file included in this distribution.\n"
-"//\n"
-"// **********************************************************************\n"
-        ;
-
-    _out << header;
-    _out << "//\n";
-    _out << "// Ice version " << ICE_STRING_VERSION << "\n";
-    _out << "//\n";
-}
-
 Slice::Gen::RequireVisitor::RequireVisitor(IceUtilInternal::Output& out, vector<string> includePaths,
                                            bool icejs, bool es6modules) :
     JsVisitor(out),
@@ -549,9 +847,17 @@ void
 Slice::Gen::RequireVisitor::visitSequence(const SequencePtr& seq)
 {
     BuiltinPtr builtin = BuiltinPtr::dynamicCast(seq->type());
-    if(builtin && builtin->kind() == Builtin::KindObject)
+    if(builtin)
     {
-        _seenObjectSeq = true;
+        switch(builtin->kind())
+        {
+        case Builtin::KindObject:
+            _seenObjectSeq = true;
+        case Builtin::KindObjectProxy:
+            _seenObjectProxySeq = true;
+        default:
+            break;
+        }
     }
 }
 
@@ -559,9 +865,17 @@ void
 Slice::Gen::RequireVisitor::visitDictionary(const DictionaryPtr& dict)
 {
     BuiltinPtr builtin = BuiltinPtr::dynamicCast(dict->valueType());
-    if(builtin && builtin->kind() == Builtin::KindObject)
+    if(builtin)
     {
-        _seenObjectDict = true;
+        switch(builtin->kind())
+        {
+        case Builtin::KindObject:
+            _seenObjectDict = true;
+        case Builtin::KindObjectProxy:
+            _seenObjectProxyDict = true;
+        default:
+            break;
+        }
     }
 }
 
@@ -579,66 +893,12 @@ bool iceBuiltinModule(const string& name)
     return name == "Glacier2" || name == "Ice" || name == "IceGrid" || name == "IceMX" || name == "IceStorm";
 }
 
-string
-relativePath(string p1, string p2)
-{
-    vector<string> tokens1;
-    vector<string> tokens2;
-
-    splitString(p1, "/\\", tokens1);
-    splitString(p2, "/\\", tokens2);
-
-    string f1 = tokens1.back();
-    string f2 = tokens2.back();
-
-    tokens1.pop_back();
-    tokens2.pop_back();
-
-    vector<string>::const_iterator i1 = tokens1.begin();
-    vector<string>::const_iterator i2 = tokens2.begin();
-
-    while(i1 != tokens1.end() && i2 != tokens2.end() && *i1 == *i2)
-    {
-        i1++;
-        i2++;
-    }
-
-    //
-    // Different volumes, relative path not possible.
-    //
-    if(i1 == tokens1.begin() && i2 == tokens2.begin())
-    {
-        return p1;
-    }
-
-    string newPath;
-    if(i2 == tokens2.end())
-    {
-        newPath += "./";
-        for(; i1 != tokens1.end(); ++i1)
-        {
-            newPath += *i1 + "/";
-        }
-    }
-    else
-    {
-        for(;i2 != tokens2.end();++i2)
-        {
-            newPath += "../";
-        }
-    }
-    newPath += f1;
-
-    return newPath;
-}
-
 }
 
 vector<string>
 Slice::Gen::RequireVisitor::writeRequires(const UnitPtr& p)
 {
     vector<string> seenModules;
-
     map<string, list<string> > requires;
     if(_icejs)
     {
@@ -925,7 +1185,7 @@ Slice::Gen::TypesVisitor::visitClassDefStart(const ClassDefPtr& p)
     {
         base = bases.front();
         bases.erase(bases.begin());
-        baseRef = getReference(scope, base->scoped());
+        baseRef = fixId(base->scoped());
     }
     else
     {
@@ -1040,7 +1300,7 @@ Slice::Gen::TypesVisitor::visitClassDefStart(const ClassDefPtr& p)
             {
                 _out << nl << "super" << spar << baseParamNames << epar << ';';
             }
-            writeInitDataMembers(dataMembers, scope);
+            writeInitDataMembers(dataMembers);
             _out << eb;
 
             if(!p->isLocal())
@@ -1091,12 +1351,12 @@ Slice::Gen::TypesVisitor::visitClassDefStart(const ClassDefPtr& p)
     //
     // Define servant an proxy types for non local classes
     //
-    if(!p->isLocal())
+    if(!p->isLocal() && (p->isInterface() || !p->allOperations().empty()))
     {
         _out << sp;
         writeDocComment(p, getDeprecateReason(p, 0, "type"));
         _out << nl << localScope << "." << (p->isInterface() ? p->name() :  p->name() + "Disp") << " = class extends ";
-        if(hasBaseClass)
+        if(hasBaseClass && !base->allOperations().empty())
         {
             _out << getLocalScope(base->scope())  << "." << base->name() << "Disp";
         }
@@ -1140,7 +1400,7 @@ Slice::Gen::TypesVisitor::visitClassDefStart(const ClassDefPtr& p)
         // Generate a proxy class for interfaces or classes with operations.
         //
         string proxyType = "undefined";
-        if(p->isInterface() || p->allOperations().size() > 0)
+        if(p->isInterface() || !p->allOperations().empty())
         {
             proxyType = localScope + '.' + prxName;
             string baseProxy = "Ice.ObjectPrx";
@@ -1442,7 +1702,7 @@ Slice::Gen::TypesVisitor::visitExceptionStart(const ExceptionPtr& p)
     string baseRef;
     if(base)
     {
-        baseRef = getReference(scope, base->scoped());
+        baseRef = fixId(base->scoped());
     }
     else
     {
@@ -1514,7 +1774,7 @@ Slice::Gen::TypesVisitor::visitExceptionStart(const ExceptionPtr& p)
     _out << "_cause = \"\"" << epar;
     _out << sb;
     _out << nl << "super" << spar << baseParamNames << "_cause" << epar << ';';
-    writeInitDataMembers(dataMembers, scope);
+    writeInitDataMembers(dataMembers);
     _out << eb;
 
     _out << sp;
@@ -1529,8 +1789,6 @@ Slice::Gen::TypesVisitor::visitExceptionStart(const ExceptionPtr& p)
     _out << nl << "return \"" << p->scoped() << "\";";
     _out << eb;
 
-    // TODO: equals?
-
     if(!p->isLocal())
     {
         _out << sp;
@@ -1630,7 +1888,7 @@ Slice::Gen::TypesVisitor::visitStructStart(const StructPtr& p)
 
     _out << epar;
     _out << sb;
-    writeInitDataMembers(dataMembers, scope);
+    writeInitDataMembers(dataMembers);
     _out << eb;
 
     if(!p->isLocal())
@@ -1900,3 +2158,1038 @@ Slice::Gen::ExportVisitor::visitModuleStart(const ModulePtr& p)
     }
     return false;
 }
+
+Slice::Gen::TypeScriptRequireVisitor::TypeScriptRequireVisitor(IceUtilInternal::Output& out) :
+    JsVisitor(out),
+    _nextImport(0)
+{
+}
+
+string
+Slice::Gen::TypeScriptRequireVisitor::nextImportPrefix()
+{
+    ostringstream ns;
+    ns << "iceNS" << _nextImport++;
+    return ns.str();
+}
+
+void
+Slice::Gen::TypeScriptRequireVisitor::addImport(const TypePtr& definition, const ContainedPtr& toplevel)
+{
+    if(!BuiltinPtr::dynamicCast(definition))
+    {
+        const string m1 = getModuleMetadata(definition);
+        const string m2 = getModuleMetadata(toplevel);
+
+        const string p1 = definition->definitionContext()->filename();
+        const string p2 = toplevel->definitionContext()->filename();
+
+        addImport(m1, m2, p1, p2);
+    }
+}
+
+void
+Slice::Gen::TypeScriptRequireVisitor::addImport(const ContainedPtr& definition, const ContainedPtr& toplevel)
+{
+    const string m1 = getModuleMetadata(definition);
+    const string m2 = getModuleMetadata(toplevel);
+
+    const string p1 = definition->definitionContext()->filename();
+    const string p2 = toplevel->definitionContext()->filename();
+
+    addImport(m1, m2, p1, p2);
+}
+
+void
+Slice::Gen::TypeScriptRequireVisitor::addImport(const string& m1, const string& m2,
+                                                const string& p1, const string& p2)
+{
+    //
+    // Generate an import for a definition that is outside a JS module and comes from
+    // a different definition context or for a definition defined in a module different
+    // than the current module.
+    //
+    if(m1.empty())
+    {
+        if(p1 != p2)
+        {
+            string relpath = relativePath(p1, p2);
+
+            string::size_type pos = relpath.rfind('.');
+            if(pos != string::npos)
+            {
+                relpath.erase(pos);
+            }
+
+            for(vector<pair<string, string>>::const_iterator i = _imports.begin(); i != _imports.end(); ++i)
+            {
+                if(i->first == relpath)
+                {
+                    return;
+                }
+            }
+            _imports.push_back(make_pair(relpath, nextImportPrefix()));
+        }
+    }
+    else if(m1 != m2)
+    {
+        for(vector<pair<string, string>>::const_iterator i = _imports.begin(); i != _imports.end(); ++i)
+        {
+            if(i->first == m1)
+            {
+                return;
+            }
+        }
+        _imports.push_back(make_pair(m1, nextImportPrefix()));
+    }
+}
+
+bool
+Slice::Gen::TypeScriptRequireVisitor::visitModuleStart(const ModulePtr& p)
+{
+    //
+    // Import ice module if not building Ice
+    //
+    if(UnitPtr::dynamicCast(p->container()))
+    {
+        const string prefix = "js:module:";
+        string m;
+        findMetaData(prefix, p->getMetaData(), m);
+        if(_imports.empty() && m != "ice")
+        {
+            _imports.push_back(make_pair("ice", nextImportPrefix()));
+        }
+    }
+    return true;
+}
+
+bool
+Slice::Gen::TypeScriptRequireVisitor::visitClassDefStart(const ClassDefPtr& p)
+{
+    //
+    // Add imports required for base classes
+    //
+    ClassList bases = p->bases();
+    for(ClassList::const_iterator i = bases.begin(); i != bases.end(); ++i)
+    {
+        addImport(ContainedPtr::dynamicCast(*i), p);
+    }
+
+    //
+    // Add imports required for data members
+    //
+    const DataMemberList allDataMembers = p->allDataMembers();
+    for(DataMemberList::const_iterator i = allDataMembers.begin(); i != allDataMembers.end(); ++i)
+    {
+        addImport((*i)->type(), p);
+    }
+
+    //
+    // Add imports required for operation parameters and return type
+    //
+    const OperationList operationList = p->allOperations();
+    for(OperationList::const_iterator i = operationList.begin(); i != operationList.end(); ++i)
+    {
+        const TypePtr ret = (*i)->returnType();
+        if(ret && ret->definitionContext())
+        {
+            addImport(ret, p);
+        }
+
+        const ParamDeclList paramList = (*i)->parameters();
+        for(ParamDeclList::const_iterator j = paramList.begin(); j != paramList.end(); ++j)
+        {
+            addImport((*j)->type(), p);
+        }
+    }
+    return false;
+}
+
+bool
+Slice::Gen::TypeScriptRequireVisitor::visitStructStart(const StructPtr& p)
+{
+    //
+    // Add imports required for data members
+    //
+    const DataMemberList dataMembers = p->dataMembers();
+    for(DataMemberList::const_iterator i = dataMembers.begin(); i != dataMembers.end(); ++i)
+    {
+        addImport((*i)->type(), p);
+    }
+    return false;
+}
+
+bool
+Slice::Gen::TypeScriptRequireVisitor::visitExceptionStart(const ExceptionPtr& p)
+{
+    //
+    // Add imports required for base exceptions
+    //
+    ExceptionPtr base = p->base();
+    if(base)
+    {
+        addImport(ContainedPtr::dynamicCast(base), p);
+    }
+
+    //
+    // Add imports required for data members
+    //
+    const DataMemberList allDataMembers = p->allDataMembers();
+    for(DataMemberList::const_iterator i = allDataMembers.begin(); i != allDataMembers.end(); ++i)
+    {
+        addImport((*i)->type(), p);
+    }
+    return false;
+}
+
+void
+Slice::Gen::TypeScriptRequireVisitor::visitSequence(const SequencePtr& seq)
+{
+    //
+    // Add import required for the sequence element type
+    //
+    addImport(seq->type(), seq);
+}
+
+void
+Slice::Gen::TypeScriptRequireVisitor::visitDictionary(const DictionaryPtr& dict)
+{
+    //
+    // Add imports required for the dictionary key and value types
+    //
+    addImport(dict->keyType(), dict);
+    addImport(dict->valueType(), dict);
+}
+
+void
+Slice::Gen::TypeScriptRequireVisitor::writeRequires(const UnitPtr& p)
+{
+    for(vector<pair<string, string>>::const_iterator i = _imports.begin(); i != _imports.end(); ++i)
+    {
+        _out << nl << "import * as " << i->second << " from \"" << i->first << "\"";
+    }
+}
+
+Slice::Gen::TypeScriptAliasVisitor::TypeScriptAliasVisitor(IceUtilInternal::Output& out) :
+    JsVisitor(out)
+{
+}
+
+void
+Slice::Gen::TypeScriptAliasVisitor::addAlias(const ExceptionPtr& type, const ContainedPtr& toplevel)
+{
+    string m1 = getModuleMetadata(ContainedPtr::dynamicCast(type));
+    string m2 = getModuleMetadata(toplevel);
+
+    //
+    // Do not add alias for a type defined in the current module
+    //
+    if(!m1.empty() && m1 == m2)
+    {
+        return;
+    }
+
+    const string prefix = importPrefix(ContainedPtr::dynamicCast(type), toplevel, imports());
+    const string typeS = prefix + getUnqualified(fixId(type->scoped()), toplevel->scope(), prefix);
+
+    addAlias(typeS, prefix, toplevel);
+}
+
+void
+Slice::Gen::TypeScriptAliasVisitor::addAlias(const TypePtr& type, const ContainedPtr& toplevel)
+{
+    string m1 = getModuleMetadata(type);
+    string m2 = getModuleMetadata(toplevel);
+
+    //
+    // Do not add alias for a type defined in the current module
+    //
+    if(!m1.empty() && m1 == m2)
+    {
+        return;
+    }
+
+    addAlias(typeToString(type, toplevel, imports(), true),
+             importPrefix(type, toplevel, imports()),
+             toplevel);
+}
+
+void
+Slice::Gen::TypeScriptAliasVisitor::addAlias(const string& type, const string& prefix,
+                                             const ContainedPtr& toplevel)
+{
+    const string scope = fixId(toplevel->scoped()) + ".";
+    //
+    // When using an import prefix we don't need an alias, prefixes use iceNSXX that is reserved
+    // name prefix
+    //
+    string::size_type i = type.find(".");
+    if(prefix.empty() && i != string::npos)
+    {
+        if(scope.find("." + type.substr(0, i + 1)) != string::npos)
+        {
+            for(vector<pair<string, string>>::const_iterator j = _aliases.begin(); j != _aliases.end(); ++j)
+            {
+                if(j->first == type)
+                {
+                    return;
+                }
+            }
+            string alias = type;
+            replace(alias.begin(), alias.end(), '.', '_');
+            //
+            // We prefix alias with iceA this avoid conflict with iceNSX used for
+            // import prefixes
+            //
+            _aliases.push_back(make_pair(type, "iceA_" + alias));
+        }
+    }
+}
+
+bool
+Slice::Gen::TypeScriptAliasVisitor::visitModuleStart(const ModulePtr& p)
+{
+    return true;
+}
+
+bool
+Slice::Gen::TypeScriptAliasVisitor::visitClassDefStart(const ClassDefPtr& p)
+{
+    ModulePtr module = ModulePtr::dynamicCast(p->container());
+    //
+    // Add alias required for base classes
+    //
+    ClassList bases = p->bases();
+    for(ClassList::const_iterator i = bases.begin(); i != bases.end(); ++i)
+    {
+        addAlias(TypePtr::dynamicCast((*i)->declaration()), module);
+    }
+
+    //
+    // Add alias required for data members
+    //
+    const DataMemberList allDataMembers = p->allDataMembers();
+    for(DataMemberList::const_iterator i = allDataMembers.begin(); i != allDataMembers.end(); ++i)
+    {
+        addAlias((*i)->type(), module);
+    }
+
+    //
+    // Add alias required for operation parameters
+    //
+    const OperationList operationList = p->allOperations();
+    for(OperationList::const_iterator i = operationList.begin(); i != operationList.end(); ++i)
+    {
+        const TypePtr ret = (*i)->returnType();
+        if(ret && ret->definitionContext())
+        {
+            addAlias(ret, module);
+        }
+
+        const ParamDeclList paramList = (*i)->parameters();
+        for(ParamDeclList::const_iterator j = paramList.begin(); j != paramList.end(); ++j)
+        {
+            addAlias((*j)->type(), module);
+        }
+    }
+    return false;
+}
+
+bool
+Slice::Gen::TypeScriptAliasVisitor::visitStructStart(const StructPtr& p)
+{
+    ModulePtr module = ModulePtr::dynamicCast(p->container());
+    //
+    // Add alias required for data members
+    //
+    const DataMemberList dataMembers = p->dataMembers();
+    for(DataMemberList::const_iterator i = dataMembers.begin(); i != dataMembers.end(); ++i)
+    {
+        addAlias((*i)->type(), module);
+    }
+    return false;
+}
+
+bool
+Slice::Gen::TypeScriptAliasVisitor::visitExceptionStart(const ExceptionPtr& p)
+{
+    ModulePtr module = ModulePtr::dynamicCast(p->container());
+    //
+    // Add alias required for base exception
+    //
+    ExceptionPtr base = p->base();
+    if(base)
+    {
+        addAlias(base, module);
+    }
+
+    //
+    // Add alias required for data members
+    //
+    const DataMemberList allDataMembers = p->allDataMembers();
+    for(DataMemberList::const_iterator i = allDataMembers.begin(); i != allDataMembers.end(); ++i)
+    {
+        addAlias((*i)->type(), module);
+    }
+    return false;
+}
+
+void
+Slice::Gen::TypeScriptAliasVisitor::visitSequence(const SequencePtr& seq)
+{
+    addAlias(seq->type(), ModulePtr::dynamicCast(seq->container()));
+}
+
+void
+Slice::Gen::TypeScriptAliasVisitor::visitDictionary(const DictionaryPtr& dict)
+{
+    ModulePtr module = ModulePtr::dynamicCast(dict->container());
+    addAlias(dict->keyType(), module);
+    addAlias(dict->valueType(), module);
+}
+
+void
+Slice::Gen::TypeScriptAliasVisitor::writeAlias(const UnitPtr& p)
+{
+    if(!_aliases.empty())
+    {
+        _out << sp;
+        for(vector<pair<string, string>>::const_iterator i = _aliases.begin(); i != _aliases.end(); ++i)
+        {
+            _out << nl << "type " << i->second << " = " << i->first << ";";
+        }
+    }
+}
+
+Slice::Gen::TypeScriptVisitor::TypeScriptVisitor(::IceUtilInternal::Output& out,
+                                                 const vector<pair<string, string>>& imports) :
+    JsVisitor(out, imports)
+{
+}
+
+bool
+Slice::Gen::TypeScriptVisitor::visitModuleStart(const ModulePtr& p)
+{
+    UnitPtr unit = UnitPtr::dynamicCast(p->container());
+    if(unit)
+    {
+        string module = getModuleMetadata(ContainedPtr::dynamicCast(p));
+
+        _out << sp;
+        if(module.empty())
+        {
+            _out << nl << "export namespace " << fixId(p->name()) << sb;
+        }
+        else
+        {
+            _out << nl << "declare module \"" << fixId(module) << "\"" << sb;
+            _out << nl << "namespace " << fixId(p->name()) << sb;
+        }
+    }
+    else
+    {
+        _out << nl << "namespace " << fixId(p->name()) << sb;
+    }
+    return true;
+}
+
+void
+Slice::Gen::TypeScriptVisitor::visitModuleEnd(const ModulePtr& p)
+{
+    _out << eb; // namespace end
+
+    if(UnitPtr::dynamicCast(p->container()))
+    {
+        string module = getModuleMetadata(ContainedPtr::dynamicCast(p));
+        if(!module.empty())
+        {
+            _out << eb; // module end
+        }
+    }
+}
+
+bool
+Slice::Gen::TypeScriptVisitor::visitClassDefStart(const ClassDefPtr& p)
+{
+    const string toplevelModule = getModuleMetadata(ContainedPtr::dynamicCast(p));
+    const string icePrefix = importPrefix("Ice.", p);
+    if(p->isDelegate())
+    {
+        // A delegate only has one operation
+        OperationPtr op = p->allOperations().front();
+        CommentPtr comment = op->parseComment(false);
+        if(comment)
+        {
+            writeOpDocSummary(_out, op, comment, OpDocAllParams, true, StringList(), StringList(), comment->returns());
+        }
+        _out << nl << "type " << fixId(p->name()) << " = " << spar;
+        ParamDeclList paramList = op->parameters();
+        for(ParamDeclList::iterator q = paramList.begin(); q != paramList.end(); ++q)
+        {
+            ostringstream os;
+            os << fixId((*q)->name()) << ":";
+            if((*q)->isOutParam())
+            {
+                os << icePrefix << getUnqualified("Ice.Holder", p->scope(), icePrefix) << "<";
+            }
+            os << typeToString((*q)->type(), p, imports(), true, false, true);
+            if((*q)->isOutParam())
+            {
+                os << ">";
+            }
+            _out << os.str();
+        }
+        _out << epar << " => ";
+        TypePtr ret = op->returnType();
+        if(ret)
+        {
+            _out << typeToString(ret, p, imports(), true, false, true) << ";";
+        }
+        else
+        {
+            _out << "void;";
+        }
+    }
+    else if(p->isLocal())
+    {
+        const ClassList bases = p->bases();
+        const DataMemberList dataMembers = p->dataMembers();
+        const DataMemberList allDataMembers = p->allDataMembers();
+
+        _out << sp;
+        writeDocSummary(_out, p);
+        _out << nl;
+        _out << (p->isInterface() ? "interface" : "class") << " " << fixId(p->name());
+        if(!bases.empty() && !bases.front()->isInterface())
+        {
+            const string prefix = importPrefix(ContainedPtr::dynamicCast(bases.front()), p, imports());
+            _out << " extends " << prefix << getUnqualified(fixId(bases.front()->scoped()), p->scope(), prefix);
+        }
+        _out << sb;
+        if(!p->isInterface())
+        {
+            _out << nl << "/**";
+            _out << nl << " * One-shot constructor to initialize all data members.";
+            for(DataMemberList::const_iterator q = allDataMembers.begin(); q != allDataMembers.end(); ++q)
+            {
+                CommentPtr comment = (*q)->parseComment(false);
+                if(comment)
+                {
+                    _out << nl << " * @param " << fixId((*q)->name()) << " " << getDocSentence(comment->overview());
+                }
+            }
+            _out << nl << " */";
+            _out << nl << "constructor" << spar;
+            for(DataMemberList::const_iterator q = allDataMembers.begin(); q != allDataMembers.end(); ++q)
+            {
+                _out << (fixId((*q)->name()) + "?:" + typeToString((*q)->type(), p, imports(), true, false, true));
+            }
+            _out << epar << ";";
+
+            for(DataMemberList::const_iterator q = dataMembers.begin(); q != dataMembers.end(); ++q)
+            {
+                writeDocSummary(_out, *q);
+                _out << nl << fixId((*q)->name()) << ":" << typeToString((*q)->type(), p, imports(), true, false, true)
+                     << ";";
+            }
+        }
+
+        OperationList allOperations = p->allOperations();
+        for(OperationList::const_iterator q = allOperations.begin(); q != allOperations.end(); ++q)
+        {
+            OperationPtr op = *q;
+            ParamDeclList params = op->parameters();
+            ParamDeclList inParams, outParams;
+            for(ParamDeclList::const_iterator r = params.begin(); r != params.end(); ++r)
+            {
+                if((*r)->isOutParam())
+                {
+                    outParams.push_back(*r);
+                }
+                else
+                {
+                    inParams.push_back(*r);
+                }
+            }
+
+            TypePtr ret = op->returnType();
+            bool async = op->hasMetaData("js:async") || op->hasMetaData("async-oneway");
+            CommentPtr comment = op->parseComment(false);
+            if(comment)
+            {
+                StringList returns;
+                if(async)
+                {
+                    returns.push_back("@returns The asynchronous result object for the invocation.");
+                }
+                else if(ret)
+                {
+                    returns = comment->returns();
+                }
+                writeOpDocSummary(_out, op, comment, OpDocAllParams, true, StringList(), StringList(), returns);
+            }
+
+            _out << nl << fixId((*q)->name()) << spar;
+            for(ParamDeclList::const_iterator r = inParams.begin(); r != inParams.end(); r++)
+            {
+                _out << (fixId((*r)->name()) + ":" + typeToString((*r)->type(), p, imports(), true, false, true));
+            }
+
+            for(ParamDeclList::const_iterator r = outParams.begin(); r != outParams.end(); r++)
+            {
+                const string prefix = importPrefix("Ice.Holder", p);
+                _out << (fixId((*r)->name()) + ":"  + prefix +
+                         getUnqualified("Ice.Holder", p->scope(), prefix) + "<" +
+                         typeToString((*r)->type(), p, imports(), true, false, true) + ">");
+            }
+
+            _out << epar;
+
+            _out << ":";
+            if(async)
+            {
+               _out << icePrefix << getUnqualified("Ice.AsyncResultBase", p->scope(), icePrefix) << "<";
+            }
+
+            if(ret)
+            {
+                _out << typeToString(ret, p, imports(), true, false, true);
+            }
+            else
+            {
+                _out << "void";
+            }
+
+            if (async)
+            {
+                _out << ">";
+            }
+            _out << ";";
+        }
+
+        if(p->hasMetaData("js:comparable"))
+        {
+            _out << nl << "equals(rhs:any):boolean";
+        }
+        _out << eb;
+    }
+    else
+    {
+        //
+        // Define servant an proxy types for non local classes
+        //
+        _out << sp;
+        _out << nl << "abstract class " << fixId(p->name() + "Prx")
+             << " extends " << icePrefix << getUnqualified("Ice.ObjectPrx", p->scope(), icePrefix);
+        _out << sb;
+        const OperationList ops = p->allOperations();
+        for(OperationList::const_iterator q = ops.begin(); q != ops.end(); ++q)
+        {
+            const OperationPtr op = *q;
+            const ParamDeclList paramList = op->parameters();
+            const TypePtr ret = op->returnType();
+            ParamDeclList inParams, outParams;
+            for(ParamDeclList::const_iterator r = paramList.begin(); r != paramList.end(); ++r)
+            {
+                if((*r)->isOutParam())
+                {
+                    outParams.push_back(*r);
+                }
+                else
+                {
+                    inParams.push_back(*r);
+                }
+            }
+
+            const string contextParam = escapeParam(paramList, "context");
+            CommentPtr comment = op->parseComment(false);
+            const string contextDoc = "@param " + contextParam + " The Context map to send with the invocation.";
+            const string asyncDoc = "The asynchronous result object for the invocation.";
+            if(comment)
+            {
+                StringList postParams, returns;
+                postParams.push_back(contextDoc);
+                returns.push_back(asyncDoc);
+                writeOpDocSummary(_out, op, comment, OpDocInParams, false, StringList(), postParams, returns);
+            }
+            _out << nl << fixId((*q)->name()) << spar;
+            for(ParamDeclList::const_iterator r = inParams.begin(); r != inParams.end(); ++r)
+            {
+                _out << (fixId((*r)->name()) +
+                         ((*r)->optional() ? "?" : "") +
+                         ":" +
+                         typeToString((*r)->type(), p, imports(), true, false, true));
+            }
+            _out << "context?:Map<string, string>";
+            _out << epar;
+
+            _out << ":" << icePrefix << getUnqualified("Ice.AsyncResult", p->scope(), icePrefix);
+            if(!ret && outParams.empty())
+            {
+                _out << "<void>";
+            }
+            else if((ret && outParams.empty()) || (!ret && outParams.size() == 1))
+            {
+                TypePtr t = ret ? ret : outParams.front()->type();
+                _out << "<" << typeToString(t, p, imports(), true, false, true) << ">";
+            }
+            else
+            {
+                _out << "<[";
+                if(ret)
+                {
+                    _out << typeToString(ret, p, imports(), true, false, true) << ", ";
+                }
+
+                for(ParamDeclList::const_iterator i = outParams.begin(); i != outParams.end();)
+                {
+                    _out << typeToString((*i)->type(), p, imports(), true, false, true);
+                    if(++i != outParams.end())
+                    {
+                        _out << ", ";
+                    }
+                }
+
+                _out << "]>";
+            }
+
+            _out << ";";
+        }
+
+        const string icePrefix = importPrefix("Ice.ObjectPrx", p);
+        _out << sp;
+        _out << nl << "/**";
+        _out << nl << " * Downcasts a proxy without confirming the target object's type via a remote invocation.";
+        _out << nl << " * @param prx The target proxy.";
+        _out << nl << " * @return A proxy with the requested type.";
+        _out << nl << " */";
+        _out << nl << "static uncheckedCast(prx:" << icePrefix
+             << getUnqualified("Ice.ObjectPrx", p->scope(), icePrefix) << ", "
+             << "facet?:string):"
+             << fixId(p->name() + "Prx") << ";";
+        _out << nl << "/**";
+        _out << nl << " * Downcasts a proxy after confirming the target object's type via a remote invocation.";
+        _out << nl << " * @param prx The target proxy.";
+        _out << nl << " * @param facet A facet name.";
+        _out << nl << " * @param context The context map for the invocation.";
+        _out << nl << " * @return A proxy with the requested type and facet, or nil if the target proxy is nil or the target";
+        _out << nl << " * object does not support the requested type.";
+        _out << nl << " */";
+        _out << nl << "static checkedCast(prx:" << icePrefix
+             << getUnqualified("Ice.ObjectPrx", p->scope(), icePrefix) << ", "
+             << "facet?:string, contex?:Map<string, string>):" << icePrefix
+             << getUnqualified("Ice.AsyncResult", p->scope(), icePrefix) << "<" << fixId(p->name() + "Prx") << ">;";
+        _out << eb;
+
+        if(p->isInterface() || !ops.empty())
+        {
+            _out << sp;
+            _out << nl << "abstract class " << fixId(p->name() + (p->isInterface() ? "" : "Disp"))
+                 << " extends " << icePrefix << getUnqualified("Ice.Object", p->scope(), icePrefix);
+            _out << sb;
+            for(OperationList::const_iterator q = ops.begin(); q != ops.end(); ++q)
+            {
+                const OperationPtr op = *q;
+                const ParamDeclList paramList = op->parameters();
+                const TypePtr ret = op->returnType();
+                ParamDeclList inParams, outParams;
+                for(ParamDeclList::const_iterator r = paramList.begin(); r != paramList.end(); ++r)
+                {
+                    if((*r)->isOutParam())
+                    {
+                        outParams.push_back(*r);
+                    }
+                    else
+                    {
+                        inParams.push_back(*r);
+                    }
+                }
+
+                const string currentParam = escapeParam(inParams, "current");
+                CommentPtr comment = p->parseComment(false);
+                const string currentDoc = "@param " + currentParam + " The Current object for the invocation.";
+                const string resultDoc = "The result or a promise like object that will "
+                    "be resolved with the result of the invocation.";
+                if(comment)
+                {
+                    StringList postParams, returns;
+                    postParams.push_back(currentDoc);
+                    returns.push_back(resultDoc);
+                    writeOpDocSummary(_out, op, comment, OpDocInParams, false, StringList(), postParams, returns);
+                }
+                _out << nl << "abstract " << fixId((*q)->name()) << spar;
+                for(ParamDeclList::const_iterator r = inParams.begin(); r != inParams.end(); ++r)
+                {
+                    _out << (fixId((*r)->name()) + ":" + typeToString((*r)->type(), p, imports(), true, false, true));
+                }
+                _out << ("current:" + icePrefix + getUnqualified("Ice.Current", p->scope(), icePrefix));
+                _out << epar << ":";
+
+                if(!ret && outParams.empty())
+                {
+                    _out << "PromiseLike<void>|void";
+                }
+                else if((ret && outParams.empty()) || (!ret && outParams.size() == 1))
+                {
+                    TypePtr t = ret ? ret : outParams.front()->type();
+                    string returnType = typeToString(t, p, imports(), true, false, true);
+                    _out << "PromiseLike<" << returnType  << ">|" << returnType;
+                }
+                else
+                {
+                    ostringstream os;
+                    if(ret)
+                    {
+                        os << typeToString(ret, p, imports(), true, false, true) << ", ";
+                    }
+
+                    for(ParamDeclList::const_iterator i = outParams.begin(); i != outParams.end();)
+                    {
+                        os << typeToString((*i)->type(), p, imports(), true, false, true);
+                        if(++i != outParams.end())
+                        {
+                            os << ", ";
+                        }
+                    }
+                    _out << "PromiseLike<[" << os.str() << "]>|[" << os.str() << "]";
+                }
+                _out << ";";
+            }
+            _out << nl << "/**";
+            _out << nl << " * Obtains the Slice type ID of this type.";
+            _out << nl << " * @return The return value is always \"" + p->scoped() + "\".";
+            _out << nl << " */";
+            _out << nl << "static ice_staticId():string;";
+            _out << eb;
+        }
+
+        if(!p->isInterface())
+        {
+            const DataMemberList dataMembers = p->dataMembers();
+            const DataMemberList allDataMembers = p->allDataMembers();
+            _out << sp;
+            writeDocSummary(_out, p);
+            _out << nl << "class " << fixId(p->name()) << " extends ";
+            const string scope = p->scope();
+            const string scoped = p->scoped();
+            ClassList bases = p->bases();
+            if(!bases.empty() && !bases.front()->isInterface())
+            {
+                ClassDefPtr base = bases.front();
+                const string prefix = importPrefix(ContainedPtr::dynamicCast(base), p, imports());
+                _out << prefix << getUnqualified(fixId(base->scoped()), p->scope(), prefix);
+            }
+            else
+            {
+                _out << icePrefix << getUnqualified("Ice.Value", p->scope(), icePrefix);
+            }
+            _out << sb;
+            _out << nl << "/**";
+            _out << nl << " * One-shot constructor to initialize all data members.";
+            for(DataMemberList::const_iterator q = allDataMembers.begin(); q != allDataMembers.end(); ++q)
+            {
+                CommentPtr comment = (*q)->parseComment(false);
+                if(comment)
+                {
+                    _out << nl << " * @param " << fixId((*q)->name()) << " " << getDocSentence(comment->overview());
+                }
+            }
+            _out << nl << " */";
+            _out << nl << "constructor" << spar;
+            for(DataMemberList::const_iterator q = allDataMembers.begin(); q != allDataMembers.end(); ++q)
+            {
+                _out << (fixId((*q)->name()) + "?:" + typeToString((*q)->type(), p, imports(), true, false, true));
+            }
+            _out << epar << ";";
+            for(DataMemberList::const_iterator q = dataMembers.begin(); q != dataMembers.end(); ++q)
+            {
+                writeDocSummary(_out, *q);
+                _out << nl << fixId((*q)->name()) << ":" << typeToString((*q)->type(), p, imports(), true, false, true)
+                     << ";";
+            }
+            _out << eb;
+        }
+    }
+    return false;
+}
+
+bool
+Slice::Gen::TypeScriptVisitor::visitExceptionStart(const ExceptionPtr& p)
+{
+    const string name = fixId(p->name());
+    const DataMemberList dataMembers = p->dataMembers();
+    const DataMemberList allDataMembers = p->allDataMembers();
+    const string toplevelModule = getModuleMetadata(ContainedPtr::dynamicCast(p));
+    const string icePrefix = importPrefix("Ice.", p);
+
+    ExceptionPtr base = p->base();
+    string baseRef;
+    if(base)
+    {
+        const string prefix = importPrefix(ContainedPtr::dynamicCast(base), p, imports());
+        baseRef = prefix + getUnqualified(fixId(base->scoped()), p->scope(), prefix);
+    }
+    else
+    {
+        baseRef = p->isLocal() ?
+            icePrefix + getUnqualified("Ice.LocalException", p->scope(), icePrefix) :
+            icePrefix + getUnqualified("Ice.UserException", p->scope(), icePrefix);
+    }
+
+    _out << sp;
+    writeDocSummary(_out, p);
+    _out << nl << "class " << name << " extends " << baseRef << sb;
+    if(!allDataMembers.empty())
+    {
+        _out << nl << "/**";
+        _out << nl << " * One-shot constructor to initialize all data members.";
+        for(DataMemberList::const_iterator q = allDataMembers.begin(); q != allDataMembers.end(); ++q)
+        {
+            CommentPtr comment = (*q)->parseComment(false);
+            if(comment)
+            {
+                _out << nl << " * @param " << fixId((*q)->name()) << " " << getDocSentence(comment->overview());
+            }
+        }
+        _out << nl << " */";
+        _out << nl << "constructor" << spar;
+        for(DataMemberList::const_iterator q = allDataMembers.begin(); q != allDataMembers.end(); ++q)
+        {
+            _out << (fixId((*q)->name()) + "?:" + typeToString((*q)->type(), p, imports(), true, false, true));
+        }
+        _out << epar << ";";
+    }
+    for(DataMemberList::const_iterator q = dataMembers.begin(); q != dataMembers.end(); ++q)
+    {
+        _out << nl << fixId((*q)->name()) << ":" << typeToString((*q)->type(), p, imports(), true, false, true) << ";";
+    }
+    _out << eb;
+    return false;
+}
+
+bool
+Slice::Gen::TypeScriptVisitor::visitStructStart(const StructPtr& p)
+{
+    const string icePrefix = importPrefix("Ice.", p);
+    const string name = fixId(p->name());
+    const DataMemberList dataMembers = p->dataMembers();
+    const string toplevelModule = getModuleMetadata(ContainedPtr::dynamicCast(p));
+    _out << sp;
+    writeDocSummary(_out, p);
+    _out << nl << "class " << name << sb;
+    _out << nl << "constructor" << spar;
+    for(DataMemberList::const_iterator q = dataMembers.begin(); q != dataMembers.end(); ++q)
+    {
+        _out << (fixId((*q)->name()) + "?:" + typeToString((*q)->type(), p, imports(), true, false, true));
+    }
+    _out << epar << ";";
+
+    _out << nl << "clone():" << name << ";";
+    _out << nl << "equals(rhs:any):boolean;";
+
+    //
+    // Only generate hashCode if this structure type is a legal dictionary key type.
+    //
+    bool containsSequence = false;
+    bool legalKeyType = Dictionary::legalKeyType(p, containsSequence);
+    if(legalKeyType)
+    {
+        _out << nl << "hashCode():number;";
+    }
+
+    for(DataMemberList::const_iterator q = dataMembers.begin(); q != dataMembers.end(); ++q)
+    {
+        _out << nl << fixId((*q)->name()) << ":" << typeToString((*q)->type(), p, imports(), true, false, true) << ";";
+    }
+
+    //
+    // Streaming API
+    //
+    _out << nl << "static write(outs:" << icePrefix << getUnqualified("Ice.OutputStream", p->scope(), icePrefix)
+         << ", value:" << name << "):void;";
+    _out << nl << "static read(ins:" << icePrefix << getUnqualified("Ice.InputStream", p->scope(), icePrefix) << "):"
+         << name << ";";
+    _out << eb;
+    return false;
+}
+
+void
+Slice::Gen::TypeScriptVisitor::visitSequence(const SequencePtr& p)
+{
+    const string icePrefix = importPrefix("Ice.", p);
+    const string toplevelModule = getModuleMetadata(ContainedPtr::dynamicCast(p));
+    const string name = fixId(p->name());
+    _out << sp;
+    writeDocSummary(_out, p);
+    _out << nl << "type " << name << " = " << typeToString(p, p, imports(), true, true) << ";";
+
+    _out << sp;
+    _out << nl << "class " << fixId(p->name() + "Helper");
+    _out << sb;
+    //
+    // Streaming API
+    //
+    _out << nl << "static write(outs:" << icePrefix << getUnqualified("Ice.OutputStream", p->scope(), icePrefix)
+         << ", value:" << name << "):void;";
+    _out << nl << "static read(ins:" << icePrefix << getUnqualified("Ice.InputStream", p->scope(), icePrefix) << "):"
+         << name << ";";
+    _out << eb;
+}
+
+void
+Slice::Gen::TypeScriptVisitor::visitDictionary(const DictionaryPtr& p)
+{
+    const string icePrefix = importPrefix("Ice.", p);
+    const string toplevelModule = getModuleMetadata(ContainedPtr::dynamicCast(p));
+    const string name = fixId(p->name());
+    _out << sp;
+    writeDocSummary(_out, p);
+    _out << nl << "class " << name << " extends " << typeToString(p, p, imports(), true, true);
+    _out << sb;
+    _out << eb;
+
+    _out << sp;
+    _out << nl << "class " << fixId(p->name() + "Helper");
+    _out << sb;
+    //
+    // Streaming API
+    //
+    _out << nl << "static write(outs:" << icePrefix << getUnqualified("Ice.OutputStream", p->scope(), icePrefix)
+         << ", value:" << name << "):void;";
+    _out << nl << "static read(ins:" << icePrefix << getUnqualified("Ice.InputStream", p->scope(), icePrefix) << "):"
+         << name << ";";
+    _out << eb;
+}
+
+void
+Slice::Gen::TypeScriptVisitor::visitEnum(const EnumPtr& p)
+{
+    _out << sp;
+    writeDocSummary(_out, p);
+    _out << nl << "class " << fixId(p->name());
+    _out << sb;
+    const EnumeratorList enumerators = p->enumerators();
+    for(EnumeratorList::const_iterator en = enumerators.begin(); en != enumerators.end(); ++en)
+    {
+        writeDocSummary(_out, *en);
+        _out << nl << "static readonly " << fixId((*en)->name()) << ":" << fixId(p->name()) << ";";
+    }
+    _out << nl;
+    _out << nl << "static valueOf(value:number):" << fixId(p->name()) << ";";
+    _out << nl << "equals(other:any):boolean;";
+    _out << nl << "hashCode():number;";
+    _out << nl << "toString():string;";
+    _out << nl;
+    _out << nl << "readonly name:string;";
+    _out << nl << "readonly value:number;";
+    _out << eb;
+}
+
+void
+Slice::Gen::TypeScriptVisitor::visitConst(const ConstPtr& p)
+{
+    const string toplevelModule = getModuleMetadata(p->type());
+    _out << sp;
+    writeDocSummary(_out, p);
+    _out << nl << "const " << fixId(p->name()) << ":" << typeToString(p->type(), p, imports(), true) << ";";
+}