Port Ice.Value to JavaScript mapping

1 files changed, 16 insertions, 122 deletions

diff --git a/cpp/src/slice2js/JsUtil.cpp b/cpp/src/slice2js/JsUtil.cpp
index 641cc7c5632..8046c115102 100644
--- a/cpp/src/slice2js/JsUtil.cpp
+++ b/cpp/src/slice2js/JsUtil.cpp
@@ -28,16 +28,16 @@ using namespace IceUtil;
 using namespace IceUtilInternal;
 
 static string
-lookupKwd(const string& name, bool mangleCasts = false)
+lookupKwd(const string& name)
 {
     //
     // Keyword list. *Must* be kept in alphabetical order.
     //
     static const string keywordList[] =
     {
-        "break", "case", "catch", "class", "const", "continue", "debugger", "default", "delete", "do", "else",
-        "enum", "export", "extends", "false", "finally", "for", "function", "if", "implements", "import", "in",
-        "instanceof", "interface", "let", "new", "null", "package", "private", "protected", "public", "return",
+        "await", "break", "case", "catch", "class", "const", "continue", "debugger", "default", "delete", "do", 
+        "else", "enum", "export", "extends", "false", "finally", "for", "function", "if", "implements", "import", 
+        "in", "instanceof", "interface", "let", "new", "null", "package", "private", "protected", "public", "return",
         "static", "super", "switch", "this", "throw", "true", "try", "typeof", "var", "void", "while", "with",
         "yield"
     };
@@ -49,10 +49,7 @@ lookupKwd(const string& name, bool mangleCasts = false)
     {
         return "_" + name;
     }
-    if(mangleCasts && (name == "checkedCast" || name == "uncheckedCast"))
-    {
-        return "_" + name;
-    }
+
     return name;
 }
 
@@ -116,7 +113,7 @@ Slice::JsGenerator::isClassType(const TypePtr& type)
 // not scoped, but a JS keyword, return the "_"-prefixed name.
 //
 string
-Slice::JsGenerator::fixId(const string& name, bool mangleCasts)
+Slice::JsGenerator::fixId(const string& name)
 {
     if(name.empty())
     {
@@ -124,7 +121,7 @@ Slice::JsGenerator::fixId(const string& name, bool mangleCasts)
     }
     if(name[0] != ':')
     {
-        return lookupKwd(name, mangleCasts);
+        return lookupKwd(name);
     }
 
     const StringList ids = splitScopedName(name);
@@ -143,119 +140,13 @@ Slice::JsGenerator::fixId(const string& name, bool mangleCasts)
 }
 
 string
-Slice::JsGenerator::fixId(const ContainedPtr& cont, bool mangleCasts)
-{
-    return fixId(cont->name(), mangleCasts);
-}
-
-string
-Slice::JsGenerator::getOptionalFormat(const TypePtr& type)
-{
-    BuiltinPtr bp = BuiltinPtr::dynamicCast(type);
-    if(bp)
-    {
-        switch(bp->kind())
-        {
-        case Builtin::KindByte:
-        case Builtin::KindBool:
-        {
-            return "Ice.OptionalFormat.F1";
-        }
-        case Builtin::KindShort:
-        {
-            return "Ice.OptionalFormat.F2";
-        }
-        case Builtin::KindInt:
-        case Builtin::KindFloat:
-        {
-            return "Ice.OptionalFormat.F4";
-        }
-        case Builtin::KindLong:
-        case Builtin::KindDouble:
-        {
-            return "Ice.OptionalFormat.F8";
-        }
-        case Builtin::KindString:
-        {
-            return "Ice.OptionalFormat.VSize";
-        }
-        case Builtin::KindObject:
-        case Builtin::KindValue:
-        {
-            return "Ice.OptionalFormat.Class";
-        }
-        case Builtin::KindObjectProxy:
-        {
-            return "Ice.OptionalFormat.FSize";
-        }
-        case Builtin::KindLocalObject:
-        {
-            assert(false);
-            break;
-        }
-        }
-    }
-
-    if(EnumPtr::dynamicCast(type))
-    {
-        return "Ice.OptionalFormat.Size";
-    }
-
-    SequencePtr seq = SequencePtr::dynamicCast(type);
-    if(seq)
-    {
-        return seq->type()->isVariableLength() ? "Ice.OptionalFormat.FSize" : "Ice.OptionalFormat.VSize";
-    }
-
-    DictionaryPtr d = DictionaryPtr::dynamicCast(type);
-    if(d)
-    {
-        return (d->keyType()->isVariableLength() || d->valueType()->isVariableLength()) ?
-            "Ice.OptionalFormat.FSize" : "Ice.OptionalFormat.VSize";
-    }
-
-    StructPtr st = StructPtr::dynamicCast(type);
-    if(st)
-    {
-        return st->isVariableLength() ? "Ice.OptionalFormat.FSize" : "Ice.OptionalFormat.VSize";
-    }
-
-    if(ProxyPtr::dynamicCast(type))
-    {
-        return "Ice.OptionalFormat.FSize";
-    }
-
-    ClassDeclPtr cl = ClassDeclPtr::dynamicCast(type);
-    assert(cl);
-    return "Ice.OptionalFormat.Class";
-}
-
-string
-Slice::JsGenerator::getStaticId(const TypePtr& type)
+Slice::JsGenerator::fixId(const ContainedPtr& cont)
 {
-    BuiltinPtr b = BuiltinPtr::dynamicCast(type);
-    ClassDeclPtr cl = ClassDeclPtr::dynamicCast(type);
-
-    assert((b && b->kind() == Builtin::KindObject) || cl);
-
-    if(b)
-    {
-        return "Ice.ObjectImpl.ice_staticId()";
-    }
-    else if(cl->isInterface())
-    {
-        ContainedPtr cont = ContainedPtr::dynamicCast(cl->container());
-        assert(cont);
-        return fixId(cont->scoped()) + "." + cl->name() + "Disp_.ice_staticId()";
-    }
-    else
-    {
-        return fixId(cl->scoped()) + ".ice_staticId()";
-    }
+    return fixId(cont->name());
 }
 
 string
-Slice::JsGenerator::typeToString(const TypePtr& type, bool optional)
+Slice::JsGenerator::typeToString(const TypePtr& type)
 {
     if(!type)
     {
@@ -272,9 +163,10 @@ Slice::JsGenerator::typeToString(const TypePtr& type, bool optional)
         "Number",           // float
         "Number",           // double
         "String",
-        "Ice.Object",
+        "Ice.Value",
         "Ice.ObjectPrx",
-        "Object"
+        "Object",
+        "Ice.Value"
     };
 
     BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
@@ -298,7 +190,9 @@ Slice::JsGenerator::typeToString(const TypePtr& type, bool optional)
     DictionaryPtr d = DictionaryPtr::dynamicCast(type);
     if(d)
     {
-        return "Ice.HashMap";
+        const TypePtr keyType = d->keyType();
+        BuiltinPtr b = BuiltinPtr::dynamicCast(keyType);
+        return ((b && b->kind() == Builtin::KindLong) || StructPtr::dynamicCast(keyType)) ? "Ice.HashMap" : "Map";
     }
 
     ContainedPtr contained = ContainedPtr::dynamicCast(type);