Exemplo n.º 1
0
        public static void MapTypeName(this ISymbolMap symbols, string fullyQualifiedName, string frameworkName, TypeKind kind)
        {
            var proxyName = $"{frameworkName}Proxy";

            switch (kind)
            {
            case TypeKind.Interface:
                var defaultName = frameworkName;

                symbols
                .GetInterfaceProxyName(Arg.Is <InterfaceType>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
                .Returns(proxyName);
                symbols
                .GetInterfaceDefaultName(Arg.Is <InterfaceType>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
                .Returns(defaultName);
                symbols
                .GetInterfaceProxyNameSyntaxToken(Arg.Is <InterfaceType>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
                .Returns(SF.ParseToken(proxyName));
                symbols
                .GetInterfaceDefaultNameSyntaxToken(Arg.Is <InterfaceType>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
                .Returns(SF.ParseToken(defaultName));
                symbols
                .GetInterfaceProxyNameSyntax(Arg.Is <InterfaceType>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
                .Returns(SF.ParseName(proxyName));
                symbols
                .GetInterfaceDefaultNameSyntax(Arg.Is <InterfaceType>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
                .Returns(SF.ParseName(defaultName));

                frameworkName = $"I{frameworkName}";
                break;

            case TypeKind.Class:
                symbols
                .GetAbstractClassProxyName(Arg.Is <ClassType>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
                .Returns(proxyName);
                break;
            }

            symbols
            .GetName(Arg.Is <Type>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
            .Returns(frameworkName);
            symbols
            .GetName(Arg.Is <string>(fqn => fqn == fullyQualifiedName), disambiguate: Arg.Any <bool>())
            .Returns(frameworkName);
            symbols
            .GetNameSyntaxToken(Arg.Is <Type>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
            .Returns(SF.ParseToken(frameworkName));
            symbols
            .GetNameSyntaxToken(Arg.Is <string>(fqn => fqn == fullyQualifiedName), disambiguate: Arg.Any <bool>())
            .Returns(SF.ParseToken(frameworkName));
            symbols
            .GetNameSyntax(Arg.Is <Type>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
            .Returns(SF.ParseName(frameworkName));
            symbols
            .GetNameSyntax(Arg.Is <string>(fqn => fqn == fullyQualifiedName), disambiguate: Arg.Any <bool>())
            .Returns(SF.ParseName(frameworkName));
            symbols
            .GetTypeSyntax(Arg.Is <TypeReference>(t => t.FullyQualifiedName == fullyQualifiedName), false)
            .Returns(SF.ParseTypeName(frameworkName));
        }
Exemplo n.º 2
0
        private static SyntaxNode Normalize(SyntaxNode root, IEnumerable <SyntaxNode> members, Scope scope)
        {
            var appClass = root
                           .DescendantNodes()
                           .OfType <ClassDeclarationSyntax>()
                           .Where(@class => @class.Identifier.ToString() == "testclass")
                           .FirstOrDefault();

            if (appClass == null)
            {
                appClass = CSharp.ClassDeclaration("testclass");
            }

            return(CSharp.CompilationUnit()
                   .WithMembers(CSharp.List(new[] { (MemberDeclarationSyntax)
                                                    appClass
                                                    .WithMembers(CSharp.List(
                                                                     members.Select(
                                                                         member => {
                    var method = member as MethodDeclarationSyntax;
                    if (method == null)
                    {
                        return member;
                    }

                    return method.WithParameterList(
                        method
                        .ParameterList
                        .AddParameters(CSharp.Parameter(
                                           CSharp.ParseToken("result"))
                                       .WithType(CSharp.ParseTypeName("Dictionary<string, object>"))));
                }))) })));
        }
Exemplo n.º 3
0
 public static void MapTypeToNamespace(this ISymbolMap symbols, string fullyQualifiedName, string frameworkNamespace)
 {
     symbols
     .GetNamespace(Arg.Is <string>(n => n == fullyQualifiedName))
     .Returns(frameworkNamespace);
     symbols
     .GetNamespaceSyntaxToken(Arg.Is <string>(n => n == fullyQualifiedName))
     .Returns(SF.ParseToken(frameworkNamespace));
     symbols
     .GetNamespaceSyntax(Arg.Is <string>(n => n == fullyQualifiedName))
     .Returns(SF.ParseName(frameworkNamespace));
 }
Exemplo n.º 4
0
 public static void MapNamespace(this ISymbolMap symbols, string jsiiNamespace, string frameworkNamespace)
 {
     symbols
     .GetNamespace(Arg.Is <Type>(t => t.QualifiedNamespace == jsiiNamespace))
     .Returns(frameworkNamespace);
     symbols
     .GetNamespaceSyntaxToken(Arg.Is <Type>(t => t.QualifiedNamespace == jsiiNamespace))
     .Returns(SF.ParseToken(frameworkNamespace));
     symbols
     .GetNamespaceSyntax(Arg.Is <Type>(t => t.QualifiedNamespace == jsiiNamespace))
     .Returns(SF.ParseName(frameworkNamespace));
 }
Exemplo n.º 5
0
        public static void MapTypeName(this ISymbolMap symbols, string fullyQualifiedName, string frameworkName, TypeKind kind)
        {
            if (kind == TypeKind.Interface)
            {
                string proxyName   = $"{frameworkName}Proxy";
                string defaultName = frameworkName;

                symbols
                .GetInterfaceProxyName(Arg.Is <InterfaceType>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
                .Returns(proxyName);
                symbols
                .GetInterfaceDefaultName(Arg.Is <InterfaceType>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
                .Returns(defaultName);
                symbols
                .GetInterfaceProxyNameSyntaxToken(Arg.Is <InterfaceType>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
                .Returns(SF.ParseToken(proxyName));
                symbols
                .GetInterfaceDefaultNameSyntaxToken(Arg.Is <InterfaceType>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
                .Returns(SF.ParseToken(defaultName));
                symbols
                .GetInterfaceProxyNameSyntax(Arg.Is <InterfaceType>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
                .Returns(SF.ParseName(proxyName));
                symbols
                .GetInterfaceDefaultNameSyntax(Arg.Is <InterfaceType>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
                .Returns(SF.ParseName(defaultName));

                frameworkName = $"I{frameworkName}";
            }

            symbols
            .GetName(Arg.Is <Type>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
            .Returns(frameworkName);
            symbols
            .GetName(Arg.Is <string>(fqn => fqn == fullyQualifiedName), disambiguate: Arg.Any <bool>())
            .Returns(frameworkName);
            symbols
            .GetNameSyntaxToken(Arg.Is <Type>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
            .Returns(SF.ParseToken(frameworkName));
            symbols
            .GetNameSyntaxToken(Arg.Is <string>(fqn => fqn == fullyQualifiedName), disambiguate: Arg.Any <bool>())
            .Returns(SF.ParseToken(frameworkName));
            symbols
            .GetNameSyntax(Arg.Is <Type>(t => t.FullyQualifiedName == fullyQualifiedName), disambiguate: Arg.Any <bool>())
            .Returns(SF.ParseName(frameworkName));
            symbols
            .GetNameSyntax(Arg.Is <string>(fqn => fqn == fullyQualifiedName), disambiguate: Arg.Any <bool>())
            .Returns(SF.ParseName(frameworkName));
            symbols
            .GetTypeSyntax(Arg.Is <TypeReference>(t => t.FullyQualifiedName == fullyQualifiedName))
            .Returns(SF.ParseTypeName(frameworkName));
        }
Exemplo n.º 6
0
 public static void MapPropertyName(this ISymbolMap symbols, string ownerFullyQualifiedName, string jsiiName, string frameworkName)
 {
     symbols.GetName(
         Arg.Is <Type>(t => t.FullyQualifiedName == ownerFullyQualifiedName),
         Arg.Is <Property>(p => p.Name == jsiiName)
         ).Returns(frameworkName);
     symbols.GetNameSyntaxToken(
         Arg.Is <Type>(t => t.FullyQualifiedName == ownerFullyQualifiedName),
         Arg.Is <Property>(p => p.Name == jsiiName)
         ).Returns(SF.ParseToken(frameworkName));
     symbols.GetNameSyntax(
         Arg.Is <Type>(t => t.FullyQualifiedName == ownerFullyQualifiedName),
         Arg.Is <Property>(p => p.Name == jsiiName)
         ).Returns(SF.ParseName(frameworkName));
 }
Exemplo n.º 7
0
        public static void MapAssemblyName(this ISymbolMap symbols, string jsiiName, string frameworkName)
        {
            symbols
            .GetName(Arg.Is <Assembly>(a => a.Name == jsiiName))
            .Returns(frameworkName);
            symbols
            .GetNameSyntaxToken(Arg.Is <Assembly>(a => a.Name == jsiiName))
            .Returns(SF.ParseToken(frameworkName));
            symbols
            .GetNameSyntax(Arg.Is <Assembly>(a => a.Name == jsiiName))
            .Returns(SF.ParseName(frameworkName));

            symbols
            .GetAssemblyName(Arg.Is <string>(n => n == jsiiName))
            .Returns(frameworkName);
        }
Exemplo n.º 8
0
        private SyntaxNode memberExtension(SyntaxNode node, SyntacticalExtension <SyntaxNode> extension)
        {
            var memberDecl = node as MethodDeclarationSyntax;

            Assert.IsNotNull(memberDecl);

            return(memberDecl
                   .WithReturnType(CSharp.ParseTypeName("int"))
                   .WithIdentifier(CSharp.ParseToken("anotherName"))
                   .WithParameterList(CSharp.ParameterList())
                   .WithBody(memberDecl.Body
                             .AddStatements(new[] {
                CSharp.ParseStatement("var myFoo = 5;"),
                CSharp.ParseStatement("bar(myFoo);")
            })));
        }
Exemplo n.º 9
0
 public static void MapTypeToPackage(this ISymbolMap symbols, string fullyQualifiedName, string package)
 {
     symbols
     .GetPackage(Arg.Is <Type>(t => t.FullyQualifiedName == fullyQualifiedName))
     .Returns(package);
     symbols
     .GetPackage(Arg.Is <string>(n => n == fullyQualifiedName))
     .Returns(package);
     symbols
     .GetPackageSyntaxToken(Arg.Is <Type>(t => t.FullyQualifiedName == fullyQualifiedName))
     .Returns(SF.ParseToken(package));
     symbols
     .GetPackageSyntaxToken(Arg.Is <string>(n => n == fullyQualifiedName))
     .Returns(SF.ParseToken(package));
     symbols
     .GetPackageSyntax(Arg.Is <Type>(t => t.FullyQualifiedName == fullyQualifiedName))
     .Returns(SF.ParseName(package));
     symbols
     .GetPackageSyntax(Arg.Is <string>(n => n == fullyQualifiedName))
     .Returns(SF.ParseName(package));
 }
Exemplo n.º 10
0
        public void SyntacticalMatching()
        {
            RoslynCompiler compiler = new RoslynCompiler();
            var            syntax   = compiler.Syntax();

            //simple match
            syntax
            .match <ClassDeclarationSyntax>(c => !c.Members.OfType <ConstructorDeclarationSyntax>().Any())
            .then(addConstructor);

            var tree = compiler.ApplySyntacticalPass("class foo { } class bar { bar() {} }");

            Assert.IsTrue(tree
                          .GetRoot()
                          .DescendantNodes()
                          .OfType <ConstructorDeclarationSyntax>()
                          .Count() == 2); //must have added a constructor to "foo"

            //scope match & transform
            syntax
            .match <ClassDeclarationSyntax>(c => c.Identifier.ToString() == "foo")
            .descendants <MethodDeclarationSyntax>(named: "methods")
            .descendants <PropertyDeclarationSyntax>(prop => prop.Identifier.ToString().StartsWith("my"), named: "myProps")
            .then(syntax.transform()
                  .replace("methods", method => ((MethodDeclarationSyntax)method)
                           .WithIdentifier(CSharp.ParseToken("my" + ((MethodDeclarationSyntax)method).Identifier.ToString())))
                  .remove("myProps"));


            var scopeTree = compiler.ApplySyntacticalPass("class foo { public void Method() {} int myProp {get; set;} }");

            Assert.IsTrue(scopeTree.ToString() == "class foo { public void myMethod() {} foo (){}}");

            Assert.IsTrue(scopeTree
                          .GetRoot()
                          .DescendantNodes()
                          .OfType <ConstructorDeclarationSyntax>()
                          .Count() == 1); //must have added a constructor to "foo", since the syntax is the same
        }
Exemplo n.º 11
0
        private SyntaxNode myExtSyntactical(SyntaxNode node, Scope scope, LexicalExtension <SyntaxToken> extension)
        {
            Assert.IsTrue(node is MethodDeclarationSyntax);
            var method = node as MethodDeclarationSyntax;

            Assert.IsTrue(method.Identifier.ToString() == "__extension");

            var argString = RoslynCompiler.TokensToString(extension.Arguments);

            Assert.IsTrue(argString == "(int i) ");
            var arguments = CSharp.ParseParameterList(argString);

            var codeString = RoslynCompiler.TokensToString(extension.Body);
            var codeNode   = CSharp.ParseStatement(codeString);

            Assert.IsTrue(codeNode is BlockSyntax);
            var code = codeNode as BlockSyntax;

            return(method
                   .WithIdentifier(CSharp.ParseToken("my_ext_s"))
                   .WithParameterList(arguments)
                   .WithBody(code));
        }
Exemplo n.º 12
0
 public ParameterSyntax Build()
 => _type != null
          ? SF.Parameter(SF.List <AttributeListSyntax>(), SF.TokenList(), ParseType(_type), SF.ParseToken(_name), null)
          : SF.Parameter(SF.List <AttributeListSyntax>(), SF.TokenList(), null, SF.ParseToken(_name), null);
Exemplo n.º 13
0
 public static void MapParameterName(this ISymbolMap symbols, string jsiiName, string frameworkName)
 {
     symbols.GetName(Arg.Is <Parameter>(t => t.Name == jsiiName)).Returns(frameworkName);
     symbols.GetNameSyntaxToken(Arg.Is <Parameter>(t => t.Name == jsiiName)).Returns(SF.ParseToken(frameworkName));
     symbols.GetNameSyntax(Arg.Is <Parameter>(t => t.Name == jsiiName)).Returns(SF.ParseName(frameworkName));
 }
Exemplo n.º 14
0
 public override TypeSyntax GetTryParseMethodOutParameter()
 {
     return(SF.GenericName(SF.ParseToken(ClassDecl.FullName),
                           SF.TypeArgumentList(GetGenericParametersList())));
 }