Пример #1
0
 @Override
 public SNodeReference getReferenceRoleId(SReference reference) {
   return MapSequence.fromMap(myReferenceRolesToPointers)
       .get(
           MultiTuple.<String, String>from(
               reference.getSourceNode().getConcept().getConceptId(), reference.getRole()));
 }
Пример #2
0
 private void processReference(SModelReferenceEvent event) {
   SReference ref = event.getReference();
   final SNode sourceNode = ref.getSourceNode();
   if (sourceNode.getModel() == null) {
     return;
   }
   final SNodeId nodeId = sourceNode.getNodeId();
   final String role = ref.getRole();
   runUpdateTask(
       new _FunctionTypes._void_P0_E0() {
         public void invoke() {
           removeChanges(
               nodeId,
               SetReferenceChange.class,
               new _FunctionTypes._return_P1_E0<Boolean, SetReferenceChange>() {
                 public Boolean invoke(SetReferenceChange ch) {
                   return role.equals(ch.getRole());
                 }
               });
           buildAndAddChanges(
               new _FunctionTypes._void_P1_E0<ChangeSetBuilder>() {
                 public void invoke(ChangeSetBuilder b) {
                   b.buildForReference(getOldNode(nodeId), sourceNode, role);
                 }
               });
         }
       },
       event.getReference().getSourceNode(),
       event);
 }
Пример #3
0
 public Map<SReference, SNode> classifyUsages(Iterable<SReference> usages) {
   Map<SReference, SNode> result = MapSequence.fromMap(new HashMap<SReference, SNode>());
   for (SReference ref : Sequence.fromIterable(usages)) {
     MapSequence.fromMap(result).put(ref, ref.getTargetNode());
   }
   return result;
 }
Пример #4
0
 private static void checkModelNodes(@NotNull SModel model, @NotNull final List<String> result) {
   for (final SNode node : SNodeUtil.getDescendants(model)) {
     final SConcept concept = node.getConcept();
     if (concept == null) {
       result.add("unknown concept of node: " + SNodeUtil.getDebugText(node));
       continue;
     }
     for (String name : node.getPropertyNames()) {
       if (concept.getProperty(name) == null) {
         result.add("unknown property: `" + name + "' in node " + SNodeUtil.getDebugText(node));
       }
     }
     for (SReference ref : node.getReferences()) {
       SAbstractLink link = concept.getLink(ref.getRole());
       if (link == null || !(link.isReference())) {
         result.add(
             "unknown link role: `" + ref.getRole() + "' in node " + SNodeUtil.getDebugText(node));
       }
     }
     for (SNode child : node.getChildren()) {
       String role = child.getRoleInParent();
       SAbstractLink link = concept.getLink(role);
       if (link == null || link.isReference()) {
         result.add("unknown child role: `" + role + "' in node " + SNodeUtil.getDebugText(node));
       }
     }
   }
 }
Пример #5
0
 @Override
 protected void addReferenceCell(final SReferenceLink referenceLink) {
   SReference reference = getNode().getReference(referenceLink);
   if (reference == null) {
     addLabel("<no target>");
     return;
   }
   final SNode referentNode = reference.getTargetNode();
   if (referentNode == null) {
     String resolveInfo = ((jetbrains.mps.smodel.SReference) reference).getResolveInfo();
     String myErrorText = resolveInfo != null ? resolveInfo : "?" + referenceLink.getName() + "?";
     EditorCell_Error errorCell = new EditorCell_Error(getEditorContext(), getNode(), myErrorText);
     errorCell.setCellId("error_" + referenceLink.getName());
     addCell(errorCell);
     return;
   }
   if (referentNode.getModel() == null) {
     LOG.error("Reference to node which is not inside model. Node: " + referentNode, referentNode);
   }
   EditorCell cell =
       getUpdateSession()
           .updateReferencedNodeCell(
               new Computable<EditorCell>() {
                 @Override
                 public EditorCell compute() {
                   return createReferentEditorCell(
                       getEditorContext(), referenceLink, referentNode);
                 }
               },
               referentNode,
               referenceLink.getName());
   setSemanticNodeToCells(cell, getNode());
   cell.setCellId("reference_" + referenceLink.getName());
   addCell(cell);
 }
Пример #6
0
 @Override
 public void referenceRoleRead(SReference reference, SNodeReference linkPointer) {
   storeAndCheckConsistency(
       myReferenceRolesToPointers,
       MultiTuple.<String, String>from(
           reference.getSourceNode().getConcept().getConceptId(), reference.getRole()),
       linkPointer);
 }
Пример #7
0
 public static SNode findLinkDeclaration(SReference reference) {
   if (reference == null) {
     return null;
   }
   return ((SNode)
       SModelSearchUtil.findLinkDeclaration(
           jetbrains.mps.lang.smodel.generator.smodelAdapter.SNodeOperations.getConceptDeclaration(
               ((SNode) reference.getSourceNode())),
           reference.getRole()));
 }
Пример #8
0
 private static Map<String, Set<SReference>> createRoleToReferenceMap(SNode expectedNode) {
   Map<String, Set<SReference>> expRoleToReferenceMap = new HashMap<String, Set<SReference>>();
   for (SReference ref : expectedNode.getReferences()) {
     if (expRoleToReferenceMap.get(ref.getRole()) == null) {
       expRoleToReferenceMap.put(ref.getRole(), new HashSet<SReference>());
     }
     expRoleToReferenceMap.get(ref.getRole()).add(ref);
   }
   return expRoleToReferenceMap;
 }
  @Override
  public SNodeReference getModifiesSwitch() {
    SReference ref = mySwitch.getReference(RuleUtil.link_TemplateSwitch_modifiedSwitch);
    if (ref == null) {
      return null;
    }

    // proceed without resolving (at least for StaticReferences)
    return ref.toNodePointer();
  }
 @Override
 public List<SubstituteAction> createActions() {
   SConcept concept = mySourceNode.getConcept();
   SLanguage primaryLanguage = concept.getLanguage();
   if (primaryLanguage == null) {
     LOG.error(
         "Couldn't build actions : couldn't get declaring language for concept "
             + concept.getName());
     return Collections.emptyList();
   }
   SReference reference = mySourceNode.getReference(myLink);
   return createActions(reference == null ? null : reference.getTargetNode());
 }
Пример #11
0
  public void execute(SNode node) {
    SReference ref =
        node.getReference(((String) makeReferenceStatic_QuickFix.this.getField("role")[0]));
    SNode target = ref.getTargetNode();
    if (target == null) {
      return;
    }

    SReference staticRef =
        StaticReference.create(
            ((String) makeReferenceStatic_QuickFix.this.getField("role")[0]), node, target);
    node.setReference(((String) makeReferenceStatic_QuickFix.this.getField("role")[0]), staticRef);

    // add model import
    ((SModelBase) node.getModel()).addModelImport(target.getModel().getReference(), true);
  }
Пример #12
0
  private void processReference(String prefix, SReference ref, Consumer<SReference> consumer) {
    if (!(ref instanceof StaticReference)) return;
    SNodeId target = ref.getTargetNodeId();
    if (!(target instanceof Foreign)) return;

    String targetNodeIdStr = target.toString();

    boolean found = false;
    int idx = targetNodeIdStr.indexOf(prefix);

    while (idx >= 0) {
      if (idx == 0) {
        found = true;
        break;
      }

      char c = targetNodeIdStr.charAt(idx - 1);
      if (c == '.' || Character.isLetterOrDigit(c)) {
        idx = targetNodeIdStr.indexOf(prefix, idx + 1);
        continue;
      }

      found = true;
      break;
    }

    if (found) {
      consumer.consume(ref);
    }
  }
Пример #13
0
 private static StringBuilder checkModel(final SModel sm) {
   StringBuilder errorMessages = new StringBuilder();
   List<String> validationResult =
       ModelAccess.instance()
           .runReadAction(
               new Computable<List<String>>() {
                 public List<String> compute() {
                   return new ModelValidator(sm).validate();
                 }
               });
   if (!(validationResult.isEmpty())) {
     errorMessages.append("errors in model: ").append(sm.getReference().toString()).append("\n");
     for (String item : validationResult) {
       errorMessages.append("\t");
       errorMessages.append(item);
       errorMessages.append("\n");
     }
   }
   for (SNode node : SNodeUtil.getDescendants(sm)) {
     // Testbench.LOG.debug("Checking node " + node);
     if (SModelUtil.findConceptDeclaration(node.getConcept().getQualifiedName()) == null) {
       errorMessages.append("Unknown concept ");
       errorMessages.append(node.getConcept().getQualifiedName());
       errorMessages.append("\n");
     }
   }
   for (SNode node : SNodeUtil.getDescendants(sm)) {
     for (SReference ref : node.getReferences()) {
       if (jetbrains.mps.smodel.SNodeUtil.hasReferenceMacro(node, ref.getRole())) {
         continue;
       }
       if (SNodeOperations.getTargetNodeSilently(ref) == null) {
         errorMessages
             .append("Broken reference in model {")
             .append(SNodeOperations.getModelLongName(node.getModel()))
             .append("}")
             .append(" node ")
             .append(node.getNodeId().toString())
             .append("(")
             .append(node)
             .append(")\n");
       }
     }
   }
   return errorMessages;
 }
Пример #14
0
  private static void assertReferenceEquals(
      String errorString, SReference expectedReference, SReference actualReference) {
    if (expectedReference == null) {
      assertNull(errorString, actualReference);
      return;
    }
    assertNotNull(errorString, actualReference);

    //    assertIdEqualsOrBothNull(errorString, expectedReference.getTargetNode(),
    // actualReference.getTargetNode());
    assertEquals(
        errorString,
        ((jetbrains.mps.smodel.SReference) expectedReference).getResolveInfo(),
        ((jetbrains.mps.smodel.SReference) actualReference).getResolveInfo());
    assertEquals(errorString, expectedReference.getRole(), actualReference.getRole());
    assertEquals(
        errorString, expectedReference.getTargetNodeId(), actualReference.getTargetNodeId());
  }
Пример #15
0
    @Override
    public List<SearchResult<ModelCheckerIssue>> checkModel(
        SModel model, ProgressMonitor monitor, SRepository repository) {
      List<SearchResult<ModelCheckerIssue>> results =
          ListSequence.fromList(new ArrayList<SearchResult<ModelCheckerIssue>>());

      monitor.start("adapter usages", 1);
      for (SNode node : ListSequence.fromList(SModelOperations.getNodes(model, null))) {
        if (monitor.isCanceled()) {
          break;
        }
        // Check for adapter references
        for (SReference ref : Sequence.fromIterable(SNodeOperations.getReferences(node))) {
          SModelReference targetSModelReference = ref.getTargetSModelReference();
          if (targetSModelReference != null
              && SModelStereotype.getStereotype(targetSModelReference.getModelName())
                  .equals("java_stub")) {
            SNode target = SLinkOperations.getTargetNode(ref);
            if ((target != null)
                && SNodeOperations.isInstanceOf(
                    target, "jetbrains.mps.baseLanguage.structure.ClassConcept")) {
              String qualifiedName =
                  BehaviorReflection.invokeVirtual(
                      String.class,
                      SNodeOperations.cast(
                          target, "jetbrains.mps.baseLanguage.structure.ClassConcept"),
                      "virtual_getFqName_1213877404258",
                      new Object[] {});
              if ("jetbrains.mps.smodel.INodeAdapter".equals(qualifiedName)
                  || "jetbrains.mps.smodel.BaseAdapter".equals(qualifiedName)) {
                SpecificChecker.addIssue(
                    results,
                    node,
                    "Reference to "
                        + qualifiedName
                        + " in role `"
                        + SLinkOperations.getRole(ref)
                        + "'",
                    ModelChecker.SEVERITY_ERROR,
                    "adapter class usage",
                    null);
              }

              if (SModelStereotype.withoutStereotype(targetSModelReference.getModelName())
                      .endsWith(".structure")
                  && SModelUtil.findConceptDeclaration(qualifiedName) != null) {
                SpecificChecker.addIssue(
                    results,
                    node,
                    "Using adapter of "
                        + qualifiedName
                        + " concept in role `"
                        + SLinkOperations.getRole(ref)
                        + "'",
                    ModelChecker.SEVERITY_ERROR,
                    "adapter class usage",
                    null);
              }
            }
          }
        }
      }
      monitor.done();
      return results;
    }
Пример #16
0
 public void updateUsage(SReference usage, SNode newTarget) {
   usage.getSourceNode().setReferenceTarget(usage.getLink(), newTarget);
 }
Пример #17
0
  public int getModelKind(SModel model, @Nullable SReference reference) {
    DataSource source = (model != null ? model.getSource() : null);
    IFile modelFile =
        (source instanceof FileDataSource ? ((FileDataSource) source).getFile() : null);
    if (modelFile != null) {
      String filePath = modelFile.getAbsolutePath().replace('\\', '/');
      if (filePath.startsWith(languagesUtilPath)) {
        return OTHER;
      }
    }

    SModule module = model.getModule();
    if (module instanceof Language) {
      LanguageAspect aspect = Language.getModelAspect(model);
      if (aspect != null) {
        switch (aspect) {
          case ACTIONS:
            return EDITOR;
          case BEHAVIOR:
            return CORE;
          case CONSTRAINTS:
            return CORE;
          case DATA_FLOW:
            return CORE;
          case EDITOR:
            return EDITOR;
          case FIND_USAGES:
            return CORE;
          case INTENTIONS:
            return EDITOR;
          case PLUGIN:
            return WORKBENCH;
          case REFACTORINGS:
            return CORE;
          case SCRIPTS:
            return CORE;
          case STRUCTURE:
            return CORE;
          case STUBS:
            return CORE;
          case TEST:
            return EDITOR;
          case TEXT_GEN:
            return CORE;
          case TYPESYSTEM:
            return CORE;
          default:
        }
      }
      return CORE;

    } else if (module instanceof Solution) {

      String moduleFqName = module.getModuleName();
      if (moduleFqName.equals("JDK")) {
        return CORE;
      }
      if (moduleFqName.equals("MPS.Core")) {
        return CORE;
      }
      if (moduleFqName.equals("MPS.Editor")) {
        return EDITOR;
      }
      if (moduleFqName.equals("MPS.Workbench")) {
        return WORKBENCH;
      }
      if (moduleFqName.equals("MPS.Classpath")) {
        SNode refTargetRoot = reference.getTargetNode().getContainingRoot();
        if (SNodeOperations.isInstanceOf(
            refTargetRoot, "jetbrains.mps.baseLanguage.structure.Classifier")) {
          String cName =
              SPropertyOperations.getString(
                  SNodeOperations.cast(
                      refTargetRoot, "jetbrains.mps.baseLanguage.structure.Classifier"),
                  "name");
          String modelName = model.getModelName();
          if (findInModule(coreModule, modelName, cName)) {
            return CORE;
          }
          if (findInModule(editorModule, modelName, cName)) {
            return EDITOR;
          }
          return WORKBENCH;
        }
        return OTHER;
      }

      Solution sol = (Solution) module;
      switch (sol.getKind()) {
        case NONE:
          return OTHER;
        case PLUGIN_CORE:
          return CORE;
        case PLUGIN_EDITOR:
          return EDITOR;
        case PLUGIN_OTHER:
          return WORKBENCH;
        default:
      }
    }
    return OTHER;
  }
Пример #18
0
 public static SNode getTargetNode(SReference reference) {
   if (reference == null) {
     return null;
   }
   return reference.getTargetNode();
 }
Пример #19
0
 public static String getRole(SReference reference) {
   if (reference == null) {
     return null;
   }
   return reference.getRole();
 }