Esempio n. 1
0
        private JsStatement GenerateResourcesClass(JsClass c)
        {
            var fields = c.StaticInitStatements
                         .OfType <JsExpressionStatement>()
                         .Select(s => s.Expression)
                         .OfType <JsBinaryExpression>()
                         .Where(expr => expr.NodeType == ExpressionNodeType.Assign && expr.Left is JsMemberAccessExpression)
                         .Select(expr => new { Name = ((JsMemberAccessExpression)expr.Left).MemberName, Value = expr.Right });

            return(new JsVariableDeclarationStatement(_namer.GetTypeVariableName(_metadataImporter.GetTypeSemantics(c.CSharpTypeDefinition).Name), JsExpression.ObjectLiteral(fields.Select(f => new JsObjectLiteralProperty(f.Name, f.Value)))));
        }
Esempio n. 2
0
            public override JsExpression VisitTypeReferenceExpression(JsTypeReferenceExpression expression, object data)
            {
                var sem = _metadataImporter.GetTypeSemantics(expression.Type);

                if (sem.Type != TypeScriptSemantics.ImplType.NormalType)
                {
                    throw new ArgumentException("The type " + expression.Type.FullName + " appears in the output stage but is not a normal type.");
                }

                if (IsLocalReference(expression.Type))
                {
                    if (string.IsNullOrEmpty(sem.Name))
                    {
                        return(JsExpression.Identifier("exports"));                             // Referencing a [GlobalMethods] type. Since it was not handled in the member expression, we must be in a module, which means that the function should exist on the exports object.
                    }
                    // For types in our own assembly, we can use the $TYPE variable in the pattern "var $TYPE = function() {} ... Type.registerClass(global, 'The.Name', $TYPE)"
                    return(JsExpression.Identifier(_namer.GetTypeVariableName(_metadataImporter.GetTypeSemantics(expression.Type).Name)));
                }

                string moduleName = GetTypeModuleName(expression.Type);

                var          parts = sem.Name.Split('.');
                JsExpression result;

                if (moduleName != null)
                {
                    result = JsExpression.Identifier(GetModuleAlias(moduleName));
                    if (!string.IsNullOrEmpty(sem.Name))                        // Test for [GlobalMethods] types.
                    {
                        result = JsExpression.Member(result, parts[0]);
                    }
                }
                else
                {
                    result = JsExpression.Identifier(parts[0]);
                }

                for (int i = 1; i < parts.Length; i++)
                {
                    result = JsExpression.Member(result, parts[i]);
                }
                return(result);
            }