public void test_childrenByLinkDeclarationSpecialized() throws Exception {
   this.addNodeById("8758390115029078425");
   this.addNodeById("5815925154349132136");
   this.addNodeById("2166349271756548530");
   TestUtilities.assertEquals(
       Sequence.fromArray(
           new SNode[] {
             SNodeOperations.cast(
                 this.getNodeById("2600026384779198859"),
                 "jetbrains.mps.lang.smodelTests.structure.GrandChild")
           }),
       SNodeOperations.getChildren(
           SNodeOperations.cast(
               this.getNodeById("8758390115029078430"),
               "jetbrains.mps.lang.smodelTests.structure.ChildSubConcept"),
           SLinkOperations.findLinkDeclaration(
               "jetbrains.mps.lang.smodelTests.structure.ChildSubConcept",
               "specializedGranChild_0_1")));
   TestUtilities.assertEquals(
       Sequence.fromArray(
           new SNode[] {
             SNodeOperations.cast(
                 this.getNodeById("2600026384779198859"),
                 "jetbrains.mps.lang.smodelTests.structure.GrandChild")
           }),
       SNodeOperations.getChildren(
           SNodeOperations.cast(
               this.getNodeById("8758390115029078430"),
               "jetbrains.mps.lang.smodelTests.structure.ChildSubConcept"),
           SLinkOperations.findLinkDeclaration(
               "jetbrains.mps.lang.smodelTests.structure.Child", "grandChild_0_1")));
 }
Exemplo n.º 2
0
 public Iterable<ITarget.Name> after() {
   return Sequence.fromArray(
       new ITarget.Name[] {
         new ITarget.Name("jetbrains.mps.baseLanguage.JavaCompile.compile"),
         new ITarget.Name("jetbrains.mps.baseLanguage.JavaCompile.auxCompile")
       });
 }
Exemplo n.º 3
0
 public Iterable<IFacet.Name> required() {
   return Sequence.fromArray(
       new IFacet.Name[] {
         new IFacet.Name("jetbrains.mps.baseLanguage.JavaCompile"),
         new IFacet.Name("jetbrains.mps.lang.core.Make")
       });
 }
Exemplo n.º 4
0
 public Iterable<ITarget.Name> before() {
   return Sequence.fromArray(
       new ITarget.Name[] {
         new ITarget.Name("jetbrains.mps.lang.core.Make.reconcile"),
         new ITarget.Name("jetbrains.mps.lang.core.Make.make")
       });
 }
 public void test_childContainingRoles() throws Exception {
   this.addNodeById("8758390115029078425");
   this.addNodeById("5815925154349132136");
   this.addNodeById("2166349271756548530");
   TestUtilities.assertEquals(
       Sequence.fromArray(
           new String[] {
             SPropertyOperations.getString(
                 SLinkOperations.findLinkDeclaration(
                     "jetbrains.mps.lang.smodelTests.structure.Root", "child_1_n"),
                 "role"),
             SPropertyOperations.getString(
                 SLinkOperations.findLinkDeclaration(
                     "jetbrains.mps.lang.smodelTests.structure.Root", "childSubConcept_0_n"),
                 "role")
           }),
       ListSequence.fromList(
               SNodeOperations.getChildren(
                   SNodeOperations.cast(
                       this.getNodeById("8758390115029078426"),
                       "jetbrains.mps.lang.smodelTests.structure.Root")))
           .select(
               new ISelector<SNode, String>() {
                 public String select(SNode it) {
                   return SNodeOperations.getContainingLinkRole(it);
                 }
               }));
 }
 public void test_roles() throws Exception {
   this.addNodeById("2906110183022219846");
   this.addNodeById("2906110183022219807");
   this.addNodeById("2906110183022219843");
   this.addNodeById("2906110183022354865");
   this.addNodeById("2906110183022432276");
   TestUtilities.assertEquals(
       Sequence.fromArray(
           new String[] {
             SPropertyOperations.getString(
                 SLinkOperations.findLinkDeclaration(
                     "jetbrains.mps.lang.smodelTests.structure.ReferenceContainer", "root"),
                 "role"),
             SPropertyOperations.getString(
                 SLinkOperations.findLinkDeclaration(
                     "jetbrains.mps.lang.smodelTests.structure.ReferenceContainer", "leftChild"),
                 "role"),
             SPropertyOperations.getString(
                 SLinkOperations.findLinkDeclaration(
                     "jetbrains.mps.lang.smodelTests.structure.ReferenceContainer",
                     "rightChild"),
                 "role")
           }),
       Sequence.fromIterable(
               SNodeOperations.getReferences(
                   SNodeOperations.cast(
                       this.getNodeById("2906110183022219844"),
                       "jetbrains.mps.lang.smodelTests.structure.ReferenceContainer")))
           .select(
               new ISelector<SReference, String>() {
                 public String select(SReference it) {
                   return SLinkOperations.getRole(it);
                 }
               }));
 }
 public void test_target() throws Exception {
   this.addNodeById("2906110183022219846");
   this.addNodeById("2906110183022219807");
   this.addNodeById("2906110183022219843");
   this.addNodeById("2906110183022354865");
   this.addNodeById("2906110183022432276");
   TestUtilities.assertEquals(
       Sequence.fromArray(
           new SNode[] {
             SNodeOperations.cast(
                 this.getNodeById("2906110183022219847"),
                 "jetbrains.mps.lang.smodelTests.structure.Root"),
             SNodeOperations.cast(
                 this.getNodeById("2906110183022219848"),
                 "jetbrains.mps.lang.smodelTests.structure.Child"),
             SNodeOperations.cast(
                 this.getNodeById("2906110183022311236"),
                 "jetbrains.mps.lang.smodelTests.structure.ChildSubConcept")
           }),
       Sequence.fromIterable(
               SNodeOperations.getReferences(
                   SNodeOperations.cast(
                       this.getNodeById("2906110183022219844"),
                       "jetbrains.mps.lang.smodelTests.structure.ReferenceContainer")))
           .select(
               new ISelector<SReference, SNode>() {
                 public SNode select(SReference it) {
                   return SLinkOperations.getTargetNode(it);
                 }
               }));
 }
Exemplo n.º 8
0
 public Iterable<IFacet.Name> required() {
   return Sequence.fromArray(
       new IFacet.Name[] {
         new IFacet.Name("jetbrains.mps.lang.core.Generate"),
         new IFacet.Name("jetbrains.mps.lang.core.Make")
       });
 }
Exemplo n.º 9
0
 @Nullable
 public static ITestNodeWrapper tryToWrap(@NotNull SNode node) {
   for (TestNodeWrapperFactory factory :
       Sequence.fromIterable(Sequence.fromArray(TestNodeWrapperFactory.values()))) {
     if (factory.canWrap(node)) {
       return factory.wrap(node);
     }
   }
   return null;
 }
Exemplo n.º 10
0
 private void addTypeParams(PsiTypeParameterListOwner from, SNode to) {
   ListSequence.fromList(SLinkOperations.getTargets(to, "typeVariableDeclaration", true))
       .addSequence(
           Sequence.fromIterable(Sequence.fromArray(from.getTypeParameters()))
               .select(
                   new ISelector<PsiTypeParameter, SNode>() {
                     public SNode select(PsiTypeParameter it) {
                       return convertTypeParameter(it);
                     }
                   }));
 }
 public void test_forSpecializedLink() throws Exception {
   this.addNodeById("2906110183022219846");
   this.addNodeById("2906110183022219807");
   this.addNodeById("2906110183022219843");
   this.addNodeById("2906110183022354865");
   this.addNodeById("2906110183022432276");
   TestUtilities.assertEquals(
       Sequence.fromArray(
           new SNode[] {
             SNodeOperations.cast(
                 this.getNodeById("2906110183022311236"),
                 "jetbrains.mps.lang.smodelTests.structure.ChildSubConcept")
           }),
       Sequence.fromIterable(
               SNodeOperations.getReferences(
                   SNodeOperations.cast(
                       this.getNodeById("2906110183022354866"),
                       "jetbrains.mps.lang.smodelTests.structure.ReferenceContainerSubConcept")))
           .where(
               new IWhereFilter<SReference>() {
                 public boolean accept(SReference it) {
                   return SLinkOperations.findLinkDeclaration(it)
                       == SLinkOperations.findLinkDeclaration(
                           "jetbrains.mps.lang.smodelTests.structure.ReferenceContainer",
                           "rightChild");
                 }
               })
           .select(
               new ISelector<SReference, SNode>() {
                 public SNode select(SReference it) {
                   return SLinkOperations.getTargetNode(it);
                 }
               }));
   Assert.assertTrue(
       Sequence.fromIterable(
               SNodeOperations.getReferences(
                   SNodeOperations.cast(
                       this.getNodeById("2906110183022354866"),
                       "jetbrains.mps.lang.smodelTests.structure.ReferenceContainerSubConcept")))
           .where(
               new IWhereFilter<SReference>() {
                 public boolean accept(SReference it) {
                   return SLinkOperations.findLinkDeclaration(it)
                       == SLinkOperations.findLinkDeclaration(
                           "jetbrains.mps.lang.smodelTests.structure.ReferenceContainerSubConcept",
                           "specializedRightChild");
                 }
               })
           .isEmpty());
 }
Exemplo n.º 12
0
 public SimpleDiffRequest(
     @NotNull Project project, @Nullable SModel[] models, @NotNull String[] contentTitles) {
   super(project);
   myContentTitles = contentTitles;
   if (models != null) {
     myContents =
         Sequence.fromIterable(Sequence.fromArray(models))
             .select(
                 new ISelector<SModel, SimpleContent>() {
                   public SimpleContent select(SModel m) {
                     return new SimpleContent(
                         ModelPersistence.modelToString(m), MPSFileTypeFactory.MODEL_FILE_TYPE);
                   }
                 })
             .toGenericArray(SimpleContent.class);
   }
 }
Exemplo n.º 13
0
 private static Iterable<SNode> getWrappedConcepts(
     final _FunctionTypes._return_P1_E0<? extends Boolean, ? super TestNodeWrapperFactory>
         condition) {
   return Sequence.fromIterable(Sequence.fromArray(TestNodeWrapperFactory.values()))
       .where(
           new IWhereFilter<TestNodeWrapperFactory>() {
             public boolean accept(TestNodeWrapperFactory it) {
               return condition.invoke(it);
             }
           })
       .select(
           new ISelector<TestNodeWrapperFactory, SNode>() {
             public SNode select(TestNodeWrapperFactory it) {
               return it.getWrappedConcept();
             }
           })
       .distinct();
 }
Exemplo n.º 14
0
 @NotNull
 protected static ConfigurationFactory findFactory(
     ConfigurationType configurationType, @NonNls String configurationFactoryClassName) {
   for (ConfigurationFactory factory :
       Sequence.fromIterable(Sequence.fromArray(configurationType.getConfigurationFactories()))) {
     if (factory.getClass().getName().equals(configurationFactoryClassName)) {
       return factory;
     }
   }
   if (LOG.isEnabledFor(Priority.WARN)) {
     LOG.warn(
         "Cound not find configuration factory for "
             + configurationFactoryClassName
             + " in type "
             + configurationType.getDisplayName()
             + ".");
   }
   return configurationType.getConfigurationFactories()[0];
 }
Exemplo n.º 15
0
  private void addAnnotations(PsiModifierListOwner from, SNode to) {

    ListSequence.fromList(SLinkOperations.getTargets(to, "annotation", true))
        .addSequence(
            Sequence.fromIterable(Sequence.fromArray(from.getModifierList().getAnnotations()))
                .select(
                    new ISelector<PsiAnnotation, SNode>() {
                      public SNode select(PsiAnnotation it) {
                        PsiAnnotation psiAnno = it;
                        SNode anno = resolveAnnotation(psiAnno);
                        if ((anno == null)) {
                          return null;
                        }
                        ListSequence.fromList(SLinkOperations.getTargets(anno, "value", true))
                            .addSequence(
                                Sequence.fromIterable(
                                        Sequence.fromArray(
                                            psiAnno.getParameterList().getAttributes()))
                                    .select(
                                        new ISelector<PsiNameValuePair, SNode>() {
                                          public SNode select(PsiNameValuePair it) {

                                            SNode annoParam =
                                                SConceptOperations.createNewNode(
                                                    "jetbrains.mps.baseLanguage.structure.AnnotationInstanceValue",
                                                    null);

                                            String paramName = it.getName();
                                            annoParam.setReference(
                                                "key",
                                                new DynamicReference(
                                                    "key", annoParam, null, paramName));

                                            return annoParam;
                                          }
                                        }));

                        return anno;
                      }
                    }));
  }
Exemplo n.º 16
0
  private void addModelsForDir(
      PsiDirectory sourceRoot, PsiDirectory dir, Map<PsiJavaStubDataSource, SModel> resultMap) {
    if (Sequence.fromIterable(Sequence.fromArray(dir.getFiles()))
        .ofType(PsiJavaFile.class)
        .isNotEmpty()) {

      SModelReference modelRef = makeModelReference(sourceRoot, dir);
      SModel model = SModelRepository.getInstance().getModelDescriptor(modelRef);

      if (model == null) {
        model = makeModelDescriptor(modelRef, dir);
      }

      assert model instanceof PsiJavaStubModelDescriptor;

      PsiJavaStubDataSource dataSource = ((PsiJavaStubModelDescriptor) model).getSource();
      MapSequence.fromMap(resultMap).put(dataSource, model);
    }

    for (PsiDirectory subDir : dir.getSubdirectories()) {
      addModelsForDir(sourceRoot, subDir, resultMap);
    }
  }
 public void test_childrenByLinkDeclaration() throws Exception {
   this.addNodeById("8758390115029078425");
   this.addNodeById("5815925154349132136");
   this.addNodeById("2166349271756548530");
   List<SNode> singleChild =
       SNodeOperations.getChildren(
           SNodeOperations.cast(
               this.getNodeById("8758390115029078426"),
               "jetbrains.mps.lang.smodelTests.structure.Root"),
           SLinkOperations.findLinkDeclaration(
               "jetbrains.mps.lang.smodelTests.structure.Root", "child_1_n"));
   Assert.assertEquals(1, ListSequence.fromList(singleChild).count());
   Assert.assertEquals(
       SNodeOperations.cast(
           this.getNodeById("8758390115029078427"),
           "jetbrains.mps.lang.smodelTests.structure.Child"),
       ListSequence.fromList(singleChild).first());
   List<SNode> twins =
       SNodeOperations.getChildren(
           SNodeOperations.cast(
               this.getNodeById("5815925154349132137"),
               "jetbrains.mps.lang.smodelTests.structure.Root"),
           SLinkOperations.findLinkDeclaration(
               "jetbrains.mps.lang.smodelTests.structure.Root", "child_1_n"));
   TestUtilities.assertEquals(
       Sequence.fromArray(
           new SNode[] {
             SNodeOperations.cast(
                 this.getNodeById("5815925154349132142"),
                 "jetbrains.mps.lang.smodelTests.structure.Child"),
             SNodeOperations.cast(
                 this.getNodeById("5815925154349132138"),
                 "jetbrains.mps.lang.smodelTests.structure.Child")
           }),
       twins);
 }
Exemplo n.º 18
0
  public SNode convertTypeParameter(PsiTypeParameter x) {
    SNode typeVar =
        SConceptOperations.createNewNode(
            "jetbrains.mps.baseLanguage.structure.TypeVariableDeclaration", null);
    SPropertyOperations.set(typeVar, "name", x.getName());

    if (x.getExtendsListTypes().length > 0) {
      Iterable<PsiClassType> extend = Sequence.fromArray(x.getExtendsListTypes());
      SLinkOperations.setTarget(
          typeVar, "bound", resolveClass(Sequence.fromIterable(extend).first()), true);
      ListSequence.fromList(SLinkOperations.getTargets(typeVar, "auxBounds", true))
          .addSequence(
              Sequence.fromIterable(extend)
                  .skip(1)
                  .select(
                      new ISelector<PsiClassType, SNode>() {
                        public SNode select(PsiClassType it) {
                          return resolveClass(it);
                        }
                      }));
    }

    return typeVar;
  }
Exemplo n.º 19
0
  public SNode convertClass(PsiClass x) {

    final Wrappers._T<SNode> classifier = new Wrappers._T<SNode>();

    if (x.isAnnotationType()) {
      classifier.value =
          SConceptOperations.createNewNode("jetbrains.mps.baseLanguage.structure.Annotation", null);
    } else if (x.isEnum()) {
      classifier.value =
          SConceptOperations.createNewNode("jetbrains.mps.baseLanguage.structure.EnumClass", null);
    } else if (x.isInterface()) {
      classifier.value =
          SConceptOperations.createNewNode("jetbrains.mps.baseLanguage.structure.Interface", null);
    } else {
      classifier.value =
          SConceptOperations.createNewNode(
              "jetbrains.mps.baseLanguage.structure.ClassConcept", null);
    }

    final SNode ourConcept = SNodeOperations.getConceptDeclaration(classifier.value);

    SPropertyOperations.set(classifier.value, "name", x.getName());
    SLinkOperations.setTarget(classifier.value, "visibility", getVisibility(x), true);
    SConceptPropertyOperations.setBoolean(classifier.value, "final", isFinal(x));
    addTypeParams(x, classifier.value);

    if (isNotEmpty_rbndtb_a0m0a(SPropertyOperations.getString(classifier.value, "name"))) {
      String id =
          SNodeId.Foreign.ID_PREFIX + SPropertyOperations.getString(classifier.value, "name");
      classifier.value.setId(new SNodeId.Foreign(id));
    }

    Sequence.fromIterable(Sequence.fromArray(x.getFields()))
        .visitAll(
            new IVisitor<PsiField>() {
              public void visit(PsiField it) {
                SNode node = convertField(it, ourConcept);

                if (SNodeOperations.isInstanceOf(
                    node, "jetbrains.mps.baseLanguage.structure.StaticFieldDeclaration")) {
                  ListSequence.fromList(
                          SLinkOperations.getTargets(classifier.value, "staticField", true))
                      .addElement(
                          SNodeOperations.cast(
                              node, "jetbrains.mps.baseLanguage.structure.StaticFieldDeclaration"));
                } else if (SNodeOperations.isInstanceOf(
                    node, "jetbrains.mps.baseLanguage.structure.FieldDeclaration")) {
                  ListSequence.fromList(
                          SLinkOperations.getTargets(
                              SNodeOperations.cast(
                                  classifier.value,
                                  "jetbrains.mps.baseLanguage.structure.ClassConcept"),
                              "field",
                              true))
                      .addElement(
                          SNodeOperations.cast(
                              node, "jetbrains.mps.baseLanguage.structure.FieldDeclaration"));
                }
              }
            });

    Sequence.fromIterable(Sequence.fromArray(x.getMethods()))
        .visitAll(
            new IVisitor<PsiMethod>() {
              public void visit(PsiMethod it) {
                SNode node = convertMethod(it, ourConcept);

                if (SNodeOperations.isInstanceOf(
                    node, "jetbrains.mps.baseLanguage.structure.InstanceMethodDeclaration")) {
                  ListSequence.fromList(
                          SLinkOperations.getTargets(classifier.value, "method", true))
                      .addElement(
                          SNodeOperations.cast(
                              node,
                              "jetbrains.mps.baseLanguage.structure.InstanceMethodDeclaration"));
                } else if (SNodeOperations.isInstanceOf(
                    node, "jetbrains.mps.baseLanguage.structure.StaticMethodDeclaration")) {
                  ListSequence.fromList(
                          SLinkOperations.getTargets(
                              SNodeOperations.cast(
                                  classifier.value,
                                  "jetbrains.mps.baseLanguage.structure.ClassConcept"),
                              "staticMethod",
                              true))
                      .addElement(
                          SNodeOperations.cast(
                              node,
                              "jetbrains.mps.baseLanguage.structure.StaticMethodDeclaration"));
                } else if (SNodeOperations.isInstanceOf(
                    node, "jetbrains.mps.baseLanguage.structure.ConstructorDeclaration")) {
                  ListSequence.fromList(
                          SLinkOperations.getTargets(
                              SNodeOperations.cast(
                                  classifier.value,
                                  "jetbrains.mps.baseLanguage.structure.ClassConcept"),
                              "constructor",
                              true))
                      .addElement(
                          SNodeOperations.cast(
                              node, "jetbrains.mps.baseLanguage.structure.ConstructorDeclaration"));
                }
              }
            });

    return classifier.value;
  }
Exemplo n.º 20
0
  public SNode convertMethod(PsiMethod x, SNode parentConcept) {
    SNode method;

    if (x.isConstructor()) {
      method =
          SConceptOperations.createNewNode(
              "jetbrains.mps.baseLanguage.structure.ConstructorDeclaration", null);

    } else if (x instanceof PsiAnnotationMethod
        && SConceptOperations.isSubConceptOf(
            parentConcept, "jetbrains.mps.baseLanguage.structure.Annotation")) {
      method =
          SConceptOperations.createNewNode(
              "jetbrains.mps.baseLanguage.structure.AnnotationMethodDeclaration", null);

      if (((PsiAnnotationMethod) x).getDefaultValue() != null) {
        SNode str =
            SConceptOperations.createNewNode(
                "jetbrains.mps.baseLanguage.structure.StringLiteral", null);
        SPropertyOperations.set(str, "value", "TODO: SUPPORT EXPRESSIONS IN PSI STUBS?");
        SLinkOperations.setTarget(
            SNodeOperations.cast(
                method, "jetbrains.mps.baseLanguage.structure.AnnotationMethodDeclaration"),
            "defaultValue",
            str,
            true);
      }

    } else if (!(isStatic(x))
        || SConceptOperations.isSubConceptOf(
            parentConcept, "jetbrains.mps.baseLanguage.structure.Interface")) {
      method =
          SConceptOperations.createNewNode(
              "jetbrains.mps.baseLanguage.structure.InstanceMethodDeclaration", null);

    } else {
      method =
          SConceptOperations.createNewNode(
              "jetbrains.mps.baseLanguage.structure.StaticMethodDeclaration", null);
    }

    SPropertyOperations.set(method, "name", x.getName());
    SLinkOperations.setTarget(
        SNodeOperations.cast(method, "jetbrains.mps.baseLanguage.structure.ClassifierMember"),
        "visibility",
        getVisibility(x),
        true);
    SPropertyOperations.set(method, "isFinal", "" + (isFinal(x)));
    SPropertyOperations.set(
        method, "isSynchronized", "" + (x.hasModifierProperty(PsiModifier.SYNCHRONIZED)));

    SLinkOperations.setTarget(method, "returnType", convertType(x.getReturnType()), true);
    ListSequence.fromList(SLinkOperations.getTargets(method, "parameter", true))
        .addSequence(
            Sequence.fromIterable(Sequence.fromArray(x.getParameterList().getParameters()))
                .select(
                    new ISelector<PsiParameter, SNode>() {
                      public SNode select(PsiParameter it) {
                        SNode param =
                            SConceptOperations.createNewNode(
                                "jetbrains.mps.baseLanguage.structure.ParameterDeclaration", null);
                        SPropertyOperations.set(param, "name", it.getName());
                        SLinkOperations.setTarget(param, "type", convertType(it.getType()), true);
                        SPropertyOperations.set(param, "isFinal", "" + (isFinal(it)));

                        addAnnotations(it, param);

                        return param;
                      }
                    }));

    ListSequence.fromList(SLinkOperations.getTargets(method, "throwsItem", true))
        .addSequence(
            Sequence.fromIterable(Sequence.fromArray(x.getThrowsList().getReferencedTypes()))
                .select(
                    new ISelector<PsiClassType, SNode>() {
                      public SNode select(PsiClassType it) {
                        SNode typ = resolveClass(it);
                        return typ;
                      }
                    }));

    addTypeParams(x, method);

    // not strictly necessary
    if (x.getBody() != null) {
      SLinkOperations.setTarget(
          method,
          "body",
          SConceptOperations.createNewNode(
              "jetbrains.mps.baseLanguage.structure.StubStatementList", null),
          true);
    } else {
      SLinkOperations.setTarget(
          method,
          "body",
          SConceptOperations.createNewNode(
              "jetbrains.mps.baseLanguage.structure.StatementList", null),
          true);
    }

    return method;
  }
Exemplo n.º 21
0
 public Iterable<IFacet.Name> required() {
   return Sequence.fromArray(new IFacet.Name[] {new IFacet.Name("Maker_")});
 }
Exemplo n.º 22
0
 public Iterable<ITarget.Name> after() {
   return Sequence.fromArray(
       new ITarget.Name[] {new ITarget.Name("jetbrains.mps.lang.core.Generate.generate")});
 }
Exemplo n.º 23
0
 public Iterable<Class<? extends IResource>> expectedInput() {
   return Sequence.fromArray(EXPECTED_INPUT);
 }
Exemplo n.º 24
0
 public Iterable<IFacet.Name> extended() {
   return Sequence.fromArray(
       new IFacet.Name[] {new IFacet.Name("jetbrains.mps.make.facets.Make")});
 }
Exemplo n.º 25
0
 public List<String> getPropertyValues(
     SNode node, IScope scope, IOperationContext operationContext, EditorContext editorContext) {
   return Sequence.fromIterable(Sequence.fromArray(XmlNameUtil.getDefaultEntities()))
       .toListSequence();
 }
Exemplo n.º 26
0
 public Iterable<ITarget.Name> before() {
   return Sequence.fromArray(new ITarget.Name[] {new ITarget.Name("Maker_.Make")});
 }