cleanup
authorVladimir Krivosheev <vladimir.krivosheev@jetbrains.com>
Wed, 7 Aug 2019 16:56:10 +0000 (18:56 +0200)
committerintellij-monorepo-bot <intellij-monorepo-bot-no-reply@jetbrains.com>
Thu, 8 Aug 2019 05:06:11 +0000 (08:06 +0300)
GitOrigin-RevId: 6c66bc4b0f1c1367466350b831afba3ce1b0a1a1

platform/lang-api/src/com/intellij/facet/FacetManager.java
platform/lang-api/src/com/intellij/facet/FacetModel.java
platform/lang-impl/src/com/intellij/facet/FacetManagerImpl.java
platform/lang-impl/src/com/intellij/facet/impl/FacetModelBase.java

index 01abe00e369cf97d5696955b48d555cc7a797b19..1a340c0d17cc62b3f7e7d46305efda0076d19452 100644 (file)
@@ -1,18 +1,4 @@
-/*
- * Copyright 2000-2009 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
 
 package com.intellij.facet;
 
@@ -39,16 +25,16 @@ public abstract class FacetManager implements FacetModel {
   public abstract ModifiableFacetModel createModifiableModel();
 
   @NotNull
-  public abstract <F extends Facet, C extends FacetConfiguration> F createFacet(@NotNull FacetType<F, C> type, @NotNull String name,
-                                                                                   @NotNull C configuration, @Nullable Facet underlying);
+  public abstract <F extends Facet<?>, C extends FacetConfiguration> F createFacet(@NotNull FacetType<F, C> type, @NotNull String name,
+                                                                                   @NotNull C configuration, @Nullable Facet<?> underlying);
 
 
   @NotNull
-  public abstract <F extends Facet, C extends FacetConfiguration> F createFacet(@NotNull FacetType<F, C> type, @NotNull String name,
-                                                                                   @Nullable Facet underlying);
+  public abstract <F extends Facet<?>, C extends FacetConfiguration> F createFacet(@NotNull FacetType<F, C> type, @NotNull String name,
+                                                                                   @Nullable Facet<?> underlying);
 
   @NotNull
-  public abstract <F extends Facet, C extends FacetConfiguration> F addFacet(@NotNull FacetType<F, C> type, @NotNull String name, 
-                                                                                   @Nullable Facet underlying);
+  public abstract <F extends Facet<?>, C extends FacetConfiguration> F addFacet(@NotNull FacetType<F, C> type, @NotNull String name,
+                                                                                   @Nullable Facet<?> underlying);
 
 }
index df0aa2188c82b1c847a4445d9862650225668f77..11dda1bcc7c3d19f5449fe4b2de3888fd6227c71 100644 (file)
@@ -1,18 +1,4 @@
-/*
- * Copyright 2000-2009 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
 
 package com.intellij.facet;
 
@@ -30,27 +16,27 @@ public interface FacetModel {
    * @return sorted array of facets
    */
   @NotNull
-  Facet[] getSortedFacets();
+  Facet<?>[] getSortedFacets();
 
   /**
    * @return all facets in the module
    */
   @NotNull
-  Facet[] getAllFacets();
+  Facet<?>[] getAllFacets();
 
   /**
    * @param typeId type of facets
    * @return all facets of the given type
    */
   @NotNull
-  <F extends Facet> Collection<F> getFacetsByType(FacetTypeId<F> typeId);
+  <F extends Facet<?>> Collection<F> getFacetsByType(FacetTypeId<F> typeId);
 
   /**
    * @param typeId type of facet
    * @return first facet of the given type or {@code null} if the module doesn't contain facets of this type
    */
   @Nullable
-  <F extends Facet> F getFacetByType(FacetTypeId<F> typeId);
+  <F extends Facet<?>> F getFacetByType(FacetTypeId<F> typeId);
 
   /**
    * @param type type of facet
@@ -58,7 +44,7 @@ public interface FacetModel {
    * @return first facet of the given type with the given name or {@code null} if not found
    */
   @Nullable
-  <F extends Facet> F findFacet(FacetTypeId<F> type, String name);
+  <F extends Facet<?>> F findFacet(FacetTypeId<F> type, String name);
 
   /**
    * @param underlyingFacet facet
@@ -66,7 +52,7 @@ public interface FacetModel {
    * @return first subfacet of the given facet
    */
   @Nullable
-  <F extends Facet> F getFacetByType(@NotNull Facet underlyingFacet, FacetTypeId<F> typeId);
+  <F extends Facet<?>> F getFacetByType(@NotNull Facet<?> underlyingFacet, FacetTypeId<F> typeId);
 
   /**
    * @param underlyingFacet facet
@@ -74,8 +60,8 @@ public interface FacetModel {
    * @return all subfacets of the given facet
    */
   @NotNull
-  <F extends Facet> Collection<F> getFacetsByType(@NotNull Facet underlyingFacet, FacetTypeId<F> typeId);
+  <F extends Facet<?>> Collection<F> getFacetsByType(@NotNull Facet<?> underlyingFacet, FacetTypeId<F> typeId);
 
   @NotNull
-  String getFacetName(@NotNull Facet facet);
+  String getFacetName(@NotNull Facet<?> facet);
 }
index 4b372ec3ebf893094f9d76e45a18f3adbf9abc07..d38e2200a98dea49a093205afb5daa1b2c75c641 100644 (file)
@@ -70,58 +70,58 @@ public final class FacetManagerImpl extends FacetManager implements ModuleCompon
 
   @Override
   @NotNull
-  public Facet[] getAllFacets() {
+  public Facet<?>[] getAllFacets() {
     return myModel.getAllFacets();
   }
 
   @Override
   @Nullable
-  public <F extends Facet> F getFacetByType(FacetTypeId<F> typeId) {
+  public <F extends Facet<?>> F getFacetByType(FacetTypeId<F> typeId) {
     return myModel.getFacetByType(typeId);
   }
 
   @Override
   @Nullable
-  public <F extends Facet> F findFacet(final FacetTypeId<F> type, final String name) {
+  public <F extends Facet<?>> F findFacet(final FacetTypeId<F> type, final String name) {
     return myModel.findFacet(type, name);
   }
 
   @Override
   @Nullable
-  public <F extends Facet> F getFacetByType(@NotNull final Facet underlyingFacet, final FacetTypeId<F> typeId) {
+  public <F extends Facet<?>> F getFacetByType(@NotNull final Facet<?> underlyingFacet, final FacetTypeId<F> typeId) {
     return myModel.getFacetByType(underlyingFacet, typeId);
   }
 
   @Override
   @NotNull
-  public <F extends Facet> Collection<F> getFacetsByType(@NotNull final Facet underlyingFacet, final FacetTypeId<F> typeId) {
+  public <F extends Facet<?>> Collection<F> getFacetsByType(@NotNull final Facet<?> underlyingFacet, final FacetTypeId<F> typeId) {
     return myModel.getFacetsByType(underlyingFacet, typeId);
   }
 
 
   @Override
   @NotNull
-  public <F extends Facet> Collection<F> getFacetsByType(FacetTypeId<F> typeId) {
+  public <F extends Facet<?>> Collection<F> getFacetsByType(FacetTypeId<F> typeId) {
     return myModel.getFacetsByType(typeId);
   }
 
 
   @Override
   @NotNull
-  public Facet[] getSortedFacets() {
+  public Facet<?>[] getSortedFacets() {
     return myModel.getSortedFacets();
   }
 
   @Override
   @NotNull
-  public String getFacetName(@NotNull Facet facet) {
+  public String getFacetName(@NotNull Facet<?> facet) {
     return myModel.getFacetName(facet);
   }
 
   @Override
   @NotNull
-  public <F extends Facet, C extends FacetConfiguration> F createFacet(@NotNull final FacetType<F, C> type, @NotNull final String name, @NotNull final C configuration,
-                                                                          @Nullable final Facet underlying) {
+  public <F extends Facet<?>, C extends FacetConfiguration> F createFacet(@NotNull final FacetType<F, C> type, @NotNull final String name, @NotNull final C configuration,
+                                                                          @Nullable final Facet<?> underlying) {
     final F facet = type.createFacet(myModule, name, configuration, underlying);
     assertTrue(facet.getModule() == myModule, facet, "module");
     assertTrue(facet.getConfiguration() == configuration, facet, "configuration");
@@ -132,14 +132,14 @@ public final class FacetManagerImpl extends FacetManager implements ModuleCompon
 
   @Override
   @NotNull
-  public <F extends Facet, C extends FacetConfiguration> F createFacet(@NotNull final FacetType<F, C> type, @NotNull final String name, @Nullable final Facet underlying) {
+  public <F extends Facet<?>, C extends FacetConfiguration> F createFacet(@NotNull final FacetType<F, C> type, @NotNull final String name, @Nullable final Facet<?> underlying) {
     C configuration = ProjectFacetManager.getInstance(myModule.getProject()).createDefaultConfiguration(type);
     return createFacet(type, name, configuration, underlying);
   }
 
   @Override
   @NotNull
-  public <F extends Facet, C extends FacetConfiguration> F addFacet(@NotNull final FacetType<F, C> type, @NotNull final String name, @Nullable final Facet underlying) {
+  public <F extends Facet<?>, C extends FacetConfiguration> F addFacet(@NotNull final FacetType<F, C> type, @NotNull final String name, @Nullable final Facet<?> underlying) {
     final ModifiableFacetModel model = createModifiableModel();
     final F facet = createFacet(type, name, underlying);
     model.addFacet(facet);
@@ -147,14 +147,14 @@ public final class FacetManagerImpl extends FacetManager implements ModuleCompon
     return facet;
   }
 
-  private static void assertTrue(final boolean value, final Facet facet, final String parameter) {
+  private static void assertTrue(final boolean value, final Facet<?> facet, final String parameter) {
     if (!value) {
       LOG.error("Facet type " + facet.getType().getClass().getName() + " violates the contract of FacetType.createFacet method about '" +
                 parameter + "' parameter");
     }
   }
 
-  private void addFacets(final List<? extends FacetState> facetStates, final Facet underlyingFacet, ModifiableFacetModel model) {
+  private void addFacets(final List<? extends FacetState> facetStates, final Facet<?> underlyingFacet, ModifiableFacetModel model) {
 
     FacetTypeRegistry registry = FacetTypeRegistry.getInstance();
     for (FacetState child : facetStates) {
@@ -170,7 +170,7 @@ public final class FacetManagerImpl extends FacetManager implements ModuleCompon
         continue;
       }
 
-      ModuleType moduleType = ModuleType.get(myModule);
+      ModuleType<?> moduleType = ModuleType.get(myModule);
       if (!type.isSuitableModuleType(moduleType)) {
         addInvalidFacet(child, model, underlyingFacet, ProjectBundle.message("error.message.0.facets.are.not.allowed.in.1",
                                                                       type.getPresentableName(), moduleType.getName()));
@@ -182,7 +182,7 @@ public final class FacetManagerImpl extends FacetManager implements ModuleCompon
       if (underlyingTypeId != null) {
         expectedUnderlyingType = registry.findFacetType(underlyingTypeId);
       }
-      FacetType actualUnderlyingType = underlyingFacet != null ? underlyingFacet.getType() : null;
+      FacetType<?, ?> actualUnderlyingType = underlyingFacet != null ? underlyingFacet.getType() : null;
       if (expectedUnderlyingType != null) {
         if (!expectedUnderlyingType.equals(actualUnderlyingType)) {
           addInvalidFacet(child, model, underlyingFacet, ProjectBundle.message("error.message.0.facet.must.be.placed.under.1.facet",
@@ -209,14 +209,14 @@ public final class FacetManagerImpl extends FacetManager implements ModuleCompon
 
   private void addInvalidFacet(final FacetState state,
                                ModifiableFacetModel model,
-                               final Facet underlyingFacet,
+                               final Facet<?> underlyingFacet,
                                final String errorMessage) {
     addInvalidFacet(state, model, underlyingFacet, errorMessage, null);
   }
 
   private void addInvalidFacet(final FacetState state,
                                ModifiableFacetModel model,
-                               final Facet underlyingFacet,
+                               final Facet<?> underlyingFacet,
                                final String errorMessage,
                                final String typeId) {
     final InvalidFacetManager invalidFacetManager = InvalidFacetManager.getInstance(myModule.getProject());
@@ -233,7 +233,7 @@ public final class FacetManagerImpl extends FacetManager implements ModuleCompon
     }
   }
 
-  private <F extends Facet<C>, C extends FacetConfiguration> void addFacet(final FacetType<F, C> type, final FacetState state, final Facet underlyingFacet,
+  private <F extends Facet<C>, C extends FacetConfiguration> void addFacet(final FacetType<F, C> type, final FacetState state, final Facet<?> underlyingFacet,
                                                                            final ModifiableFacetModel model) throws InvalidDataException {
     Collection<F> facetsOfThisType = underlyingFacet == null ? model.getFacetsByType(type.getId())
                                                              : model.getFacetsByType(underlyingFacet, type.getId());
@@ -299,7 +299,7 @@ public final class FacetManagerImpl extends FacetManager implements ModuleCompon
   }
 
   @NotNull
-  static Predicate<Facet> getImportedFacetPredicate(@NotNull Project project) {
+  static Predicate<Facet<?>> getImportedFacetPredicate(@NotNull Project project) {
     if (ProjectUtilCore.isExternalStorageEnabled(project)) {
       //we can store imported facets in a separate component only if that component will be stored separately, otherwise we will get modified *.iml files
       return facet -> facet.getExternalSource() != null;
@@ -308,17 +308,17 @@ public final class FacetManagerImpl extends FacetManager implements ModuleCompon
   }
 
   @NotNull
-  FacetManagerState saveState(Predicate<? super Facet> filter) {
+  FacetManagerState saveState(Predicate<? super Facet<?>> filter) {
     FacetManagerState managerState = new FacetManagerState();
 
-    final Facet[] facets = getSortedFacets();
+    final Facet<?>[] facets = getSortedFacets();
 
-    Map<Facet, List<FacetState>> states = new HashMap<>();
+    Map<Facet<?>, List<FacetState>> states = new HashMap<>();
     states.put(null, managerState.getFacets());
 
-    for (Facet facet : facets) {
+    for (Facet<?> facet : facets) {
       if (!filter.test(facet)) continue;
-      final Facet underlyingFacet = facet.getUnderlyingFacet();
+      final Facet<?> underlyingFacet = facet.getUnderlyingFacet();
 
       FacetState facetState = createFacetState(facet, myModule.getProject());
       if (!(facet instanceof InvalidFacet)) {
@@ -347,7 +347,7 @@ public final class FacetManagerImpl extends FacetManager implements ModuleCompon
    * Configuration of some facet may be stored in one file, but configuration of its underlying facet may be stored in another file. For such
    * sub-facets we create parent elements which don't store configuration but only name and type.
    */
-  private static List<FacetState> getOrCreateTargetFacetList(Facet underlyingFacet, Map<Facet, List<FacetState>> states, @NotNull Project project) {
+  private static List<FacetState> getOrCreateTargetFacetList(Facet<?> underlyingFacet, Map<Facet<?>, List<FacetState>> states, @NotNull Project project) {
     List<FacetState> facetStateList = states.get(underlyingFacet);
     if (facetStateList == null) {
       FacetState state = createFacetState(underlyingFacet, project);
@@ -358,7 +358,7 @@ public final class FacetManagerImpl extends FacetManager implements ModuleCompon
     return facetStateList;
   }
 
-  private static FacetState createFacetState(@NotNull Facet facet, @NotNull Project project) {
+  private static FacetState createFacetState(@NotNull Facet<?> facet, @NotNull Project project) {
     if (facet instanceof InvalidFacet) {
       return ((InvalidFacet)facet).getConfiguration().getFacetState();
     }
@@ -384,8 +384,8 @@ public final class FacetManagerImpl extends FacetManager implements ModuleCompon
   private void commit(final ModifiableFacetModel model, final boolean fireEvents) {
     LOG.assertTrue(!myInsideCommit, "Recursive commit");
 
-    Set<Facet> toRemove = new HashSet<>(Arrays.asList(getAllFacets()));
-    List<Facet> toAdd = new ArrayList<>();
+    Set<Facet<?>> toRemove = new HashSet<>(Arrays.asList(getAllFacets()));
+    List<Facet<?>> toAdd = new ArrayList<>();
     List<FacetRenameInfo> toRename = new ArrayList<>();
 
     final FacetManagerListener publisher = myMessageBus.syncPublisher(FACETS_TOPIC);
@@ -393,22 +393,22 @@ public final class FacetManagerImpl extends FacetManager implements ModuleCompon
     try {
       myInsideCommit = true;
 
-      for (Facet facet : model.getAllFacets()) {
+      for (Facet<?> facet : model.getAllFacets()) {
         boolean isNew = !toRemove.remove(facet);
         if (isNew) {
           toAdd.add(facet);
         }
       }
 
-      List<Facet> newFacets = new ArrayList<>();
-      for (Facet facet : getAllFacets()) {
+      List<Facet<?>> newFacets = new ArrayList<>();
+      for (Facet<?> facet : getAllFacets()) {
         if (!toRemove.contains(facet)) {
           newFacets.add(facet);
         }
       }
       newFacets.addAll(toAdd);
 
-      for (Facet facet : newFacets) {
+      for (Facet<?> facet : newFacets) {
         final String newName = model.getNewName(facet);
         if (newName != null && !newName.equals(facet.getName())) {
           toRename.add(new FacetRenameInfo(facet, facet.getName(), newName));
@@ -416,10 +416,10 @@ public final class FacetManagerImpl extends FacetManager implements ModuleCompon
       }
 
       if (fireEvents) {
-        for (Facet facet : toAdd) {
+        for (Facet<?> facet : toAdd) {
           publisher.beforeFacetAdded(facet);
         }
-        for (Facet facet : toRemove) {
+        for (Facet<?> facet : toRemove) {
           publisher.beforeFacetRemoved(facet);
         }
         for (FacetRenameInfo info : toRename) {
@@ -437,26 +437,26 @@ public final class FacetManagerImpl extends FacetManager implements ModuleCompon
     }
 
     if (myModuleAdded) {
-      for (Facet facet : toAdd) {
+      for (Facet<?> facet : toAdd) {
         facet.initFacet();
       }
     }
-    for (Facet facet : toRemove) {
+    for (Facet<?> facet : toRemove) {
       Disposer.dispose(facet);
     }
 
     if (fireEvents) {
-      for (Facet facet : toAdd) {
+      for (Facet<?> facet : toAdd) {
         publisher.facetAdded(facet);
       }
-      for (Facet facet : toRemove) {
+      for (Facet<?> facet : toRemove) {
         publisher.facetRemoved(facet);
       }
       for (FacetRenameInfo info : toRename) {
         publisher.facetRenamed(info.myFacet, info.myOldName);
       }
     }
-    for (Facet facet : toAdd) {
+    for (Facet<?> facet : toAdd) {
       final Module module = facet.getModule();
       if (!module.equals(myModule)) {
         LOG.error(facet + " is created for module " + module + " but added to module " + myModule);
@@ -471,7 +471,7 @@ public final class FacetManagerImpl extends FacetManager implements ModuleCompon
           }
         }
         else {
-          final Facet underlyingFacet = facet.getUnderlyingFacet();
+          final Facet<?> underlyingFacet = facet.getUnderlyingFacet();
           LOG.assertTrue(underlyingFacet != null, "Underlying facet is not specified for '" + facet.getName() + "'");
           final Collection<?> facets = getFacetsByType(underlyingFacet, type.getId());
           if (facets.size() > 1) {
@@ -482,7 +482,7 @@ public final class FacetManagerImpl extends FacetManager implements ModuleCompon
     }
   }
 
-  public void setExternalSource(Facet facet, ProjectModelExternalSource externalSource) {
+  public void setExternalSource(Facet<?> facet, ProjectModelExternalSource externalSource) {
     facet.setExternalSource(externalSource);
   }
 
@@ -494,25 +494,25 @@ public final class FacetManagerImpl extends FacetManager implements ModuleCompon
   public void moduleAdded() {
     if (myModuleAdded) return;
 
-    for (Facet facet : getAllFacets()) {
+    for (Facet<?> facet : getAllFacets()) {
       facet.initFacet();
     }
     myModuleAdded = true;
   }
 
   private static class FacetManagerModel extends FacetModelBase {
-    private Facet[] myAllFacets = Facet.EMPTY_ARRAY;
+    private Facet<?>[] myAllFacets = Facet.EMPTY_ARRAY;
     private final Set<ProjectModelExternalSource> myExternalSources = new LinkedHashSet<>();
 
     @Override
     @NotNull
-    public Facet[] getAllFacets() {
+    public Facet<?>[] getAllFacets() {
       return myAllFacets;
     }
 
-    void setAllFacets(final Facet[] allFacets) {
+    void setAllFacets(final Facet<?>[] allFacets) {
       myExternalSources.clear();
-      for (Facet facet : allFacets) {
+      for (Facet<?> facet : allFacets) {
         ContainerUtil.addIfNotNull(myExternalSources, facet.getExternalSource());
       }
       myAllFacets = allFacets;
@@ -521,11 +521,11 @@ public final class FacetManagerImpl extends FacetManager implements ModuleCompon
   }
 
   private static class FacetRenameInfo {
-    private final Facet myFacet;
+    private final Facet<?> myFacet;
     private final String myOldName;
     private final String myNewName;
 
-    FacetRenameInfo(final Facet facet, final String oldName, final String newName) {
+    FacetRenameInfo(final Facet<?> facet, final String oldName, final String newName) {
       myFacet = facet;
       myOldName = oldName;
       myNewName = newName;
index 81154477a4d9192abfb31596835e49144206f352..a5dce8e3a3f6edf60da022cb6695a9dd44bddbb8 100644 (file)
@@ -1,18 +1,4 @@
-/*
- * Copyright 2000-2009 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
 
 package com.intellij.facet.impl;
 
@@ -30,21 +16,21 @@ import java.util.*;
  * @author nik
  */
 public abstract class FacetModelBase implements FacetModel {
-  private volatile Map<FacetTypeId, Collection<Facet>> myType2Facets;
-  private volatile Map<Pair<Facet, FacetTypeId>, Collection<Facet>> myChildFacets;
-  private volatile Facet[] mySortedFacets;
+  private volatile Map<FacetTypeId<?>, Collection<Facet<?>>> myType2Facets;
+  private volatile Map<Pair<Facet<?>, FacetTypeId<?>>, Collection<Facet<?>>> myChildFacets;
+  private volatile Facet<?>[] mySortedFacets;
 
   @Override
   @NotNull
-  public Facet[] getSortedFacets() {
+  public Facet<?>[] getSortedFacets() {
     if (mySortedFacets == null) {
-      final Facet[] allFacets = getAllFacets();
+      final Facet<?>[] allFacets = getAllFacets();
       if (allFacets.length == 0) {
         mySortedFacets = Facet.EMPTY_ARRAY;
       }
       else {
-        LinkedHashSet<Facet> facets = new LinkedHashSet<>();
-        for (Facet facet : allFacets) {
+        LinkedHashSet<Facet<?>> facets = new LinkedHashSet<>();
+        for (Facet<?> facet : allFacets) {
           addUnderlyingFacets(facets, facet);
         }
         mySortedFacets = facets.toArray(Facet.EMPTY_ARRAY);
@@ -53,8 +39,8 @@ public abstract class FacetModelBase implements FacetModel {
     return mySortedFacets;
   }
 
-  private static void addUnderlyingFacets(final LinkedHashSet<? super Facet> facets, final Facet facet) {
-    final Facet underlyingFacet = facet.getUnderlyingFacet();
+  private static void addUnderlyingFacets(final LinkedHashSet<? super Facet<?>> facets, final Facet<?> facet) {
+    final Facet<?> underlyingFacet = facet.getUnderlyingFacet();
     if (underlyingFacet != null && !facets.contains(facet)) {
       addUnderlyingFacets(facets, underlyingFacet);
     }
@@ -63,25 +49,25 @@ public abstract class FacetModelBase implements FacetModel {
 
   @Override
   @NotNull
-  public <F extends Facet> Collection<F> getFacetsByType(@NotNull Facet underlyingFacet, FacetTypeId<F> typeId) {
+  public <F extends Facet<?>> Collection<F> getFacetsByType(@NotNull Facet<?> underlyingFacet, FacetTypeId<F> typeId) {
     if (myChildFacets == null) {
-      MultiValuesMap<Pair<Facet, FacetTypeId>, Facet> children = new MultiValuesMap<>();
-      for (Facet facet : getAllFacets()) {
-        final Facet underlying = facet.getUnderlyingFacet();
+      MultiValuesMap<Pair<Facet<?>, FacetTypeId<?>>, Facet<?>> children = new MultiValuesMap<>();
+      for (Facet<?> facet : getAllFacets()) {
+        final Facet<?> underlying = facet.getUnderlyingFacet();
         if (underlying != null) {
-          children.put(Pair.create(underlying,  facet.getTypeId()), facet);
+          children.put(new Pair<>(underlying,  facet.getTypeId()), facet);
         }
       }
 
-      Map<Pair<Facet, FacetTypeId>, Collection<Facet>> childFacets = new HashMap<>();
-      for (Pair<Facet, FacetTypeId> pair : children.keySet()) {
-        final Collection<Facet> facets = children.get(pair);
+      Map<Pair<Facet<?>, FacetTypeId<?>>, Collection<Facet<?>>> childFacets = new HashMap<>();
+      for (Pair<Facet<?>, FacetTypeId<?>> pair : children.keySet()) {
+        final Collection<Facet<?>> facets = children.get(pair);
         childFacets.put(pair, Collections.unmodifiableCollection(facets));
       }
       myChildFacets = childFacets;
     }
     //noinspection unchecked
-    final Collection<F> facets = (Collection<F>)myChildFacets.get(new Pair(underlyingFacet, typeId));
+    final Collection<F> facets = (Collection<F>)myChildFacets.get(new Pair<>(underlyingFacet, typeId));
     return facets != null ? facets : Collections.emptyList();
   }
 
@@ -93,7 +79,7 @@ public abstract class FacetModelBase implements FacetModel {
 
   @Override
   @Nullable
-  public <F extends Facet> F findFacet(final FacetTypeId<F> type, final String name) {
+  public <F extends Facet<?>> F findFacet(final FacetTypeId<F> type, final String name) {
     final Collection<F> fs = getFacetsByType(type);
     for (F f : fs) {
       if (f.getName().equals(name)) {
@@ -105,29 +91,29 @@ public abstract class FacetModelBase implements FacetModel {
 
   @Override
   @Nullable
-  public <F extends Facet> F getFacetByType(@NotNull final Facet underlyingFacet, final FacetTypeId<F> typeId) {
+  public <F extends Facet<?>> F getFacetByType(@NotNull final Facet<?> underlyingFacet, final FacetTypeId<F> typeId) {
     final Collection<F> fs = getFacetsByType(underlyingFacet, typeId);
     return fs.isEmpty() ? null : fs.iterator().next();
   }
 
   @Override
   @Nullable
-  public <F extends Facet> F getFacetByType(FacetTypeId<F> typeId) {
+  public <F extends Facet<?>> F getFacetByType(FacetTypeId<F> typeId) {
     final Collection<F> facets = getFacetsByType(typeId);
     return facets.isEmpty() ? null : facets.iterator().next();
   }
 
   @Override
   @NotNull
-  public <F extends Facet> Collection<F> getFacetsByType(FacetTypeId<F> typeId) {
+  public <F extends Facet<?>> Collection<F> getFacetsByType(FacetTypeId<F> typeId) {
     if (myType2Facets == null) {
-      MultiValuesMap<FacetTypeId, Facet> typeToFacets = new MultiValuesMap<>();
-      for (Facet facet : getAllFacets()) {
+      MultiValuesMap<FacetTypeId<?>, Facet<?>> typeToFacets = new MultiValuesMap<>();
+      for (Facet<?> facet : getAllFacets()) {
         typeToFacets.put(facet.getTypeId(), facet);
       }
-      Map<FacetTypeId, Collection<Facet>> typeToFacetsCollection = new HashMap<>();
-      for (FacetTypeId id : typeToFacets.keySet()) {
-        final Collection<Facet> facets = typeToFacets.get(id);
+      Map<FacetTypeId<?>, Collection<Facet<?>>> typeToFacetsCollection = new HashMap<>();
+      for (FacetTypeId<?> id : typeToFacets.keySet()) {
+        final Collection<Facet<?>> facets = typeToFacets.get(id);
         typeToFacetsCollection.put(id, Collections.unmodifiableCollection(facets));
       }
       myType2Facets = typeToFacetsCollection;