return when {
            stableSmartCasts != null -> {
                val type = stableSmartCasts.getKtType() ?: return null
                KtSmartCastInfo(type, true, token)
            }
            unstableSmartCasts != null -> {
                val type = unstableSmartCasts.getKtType() ?: return null
                KtSmartCastInfo(type, false, token)
            }
            else -> null
        }
    }

        return analysisSession.useSiteSession.typeContext
            .commonSuperTypeOrNull(types.map { it.coneType })
            ?.asKtType()
    }

    override fun getKtType(ktTypeReference: KtTypeReference): KtType {
        val fir = ktTypeReference.getFirBySymbols() ?: ktTypeReference.getOrBuildFirOfType<FirElement>(firResolveSession)
        return when (fir) {

    !returnsUnit(namedFunction) ->
        true
    namedFunction.bodyExpression == body ->
        analyze(namedFunction) {
            (body as KtExpression).getKtType()?.isUnit == true
        }
    else ->
        false
}


private fun KtAnalysisSession.isSimpleVariableAccessCall(reference: KtReferenceExpression): Boolean =

        val kotlinTypes = types.map { (it as KtFe10Type).fe10Type }
        return CommonSupertypes.commonSupertype(kotlinTypes).toKtType(analysisContext)
    }

    override fun getKtType(ktTypeReference: KtTypeReference): KtType {
        val bindingContext = analysisContext.analyze(ktTypeReference, AnalysisMode.PARTIAL)
        val kotlinType = bindingContext[BindingContext.TYPE, ktTypeReference]

            SmbResourceLocator fl = p.getLocator();
            assertNull(fl.getServer());
            assertNull(fl.getShare());
            assertEquals(SmbConstants.TYPE_WORKGROUP, fl.getType());
            assertEquals("\\", fl.getUNCPath());
            assertEquals("smb://", fl.getCanonicalURL());
            assertEquals("/", fl.getURLPath());
        }
    }


    @Test

    assertTrue(
        from.getType() + " is expected to be assignable to " + to.getType(),
        to.isSupertypeOf(from));
    assertTrue(
        to.getType() + " is expected to be a supertype of " + from.getType(),
        to.isSupertypeOf(from));
    assertTrue(
        from.getType() + " is expected to be a subtype of " + to.getType(), from.isSubtypeOf(to));
  }

      }
    }
    assertNotNull(new MyLocalClass<String>().getType());
  }

  private static <T> Type staticMethodWithAnonymousClass() {
    return new Object() {
      Type getType() {
        return new TypeToken<T>(getClass()) {}.getType();
      }
    }.getType();
  }

  public void testAnonymousClassInsideStaticMethod() {
    assertNotNull(staticMethodWithAnonymousClass());
  }

        return getter != null;
    }

    public boolean isProviderApi() {
        // TODO: Crude approximation
        return setter == null && (getType().getName().contains("Provider") || getType().getName().contains("Property"));
    }

    public ClassMetaData getOwnerClass() {
        return ownerClass;
    }

    public String getSignature() {
        StringBuilder builder = new StringBuilder();

                if (lastItem.isNull()) {
                    if (i == size() - 1 || get(i + 1).getType() == STRING_ITEM) {
                        remove(i);
                    } else if (get(i + 1).getType() == LIST_ITEM) {
                        Item item = ((ListItem) get(i + 1)).get(0);
                        if (item.getType() == COMBINATION_ITEM || item.getType() == STRING_ITEM) {
                            remove(i);
                        }

            AvPair p = it.next();
            if ( p.getType() == type ) {
                it.remove();
            }
        }
    }


    /**
     * Replace all occurances of the given type
     * 
     * @param pairs
     * @param rep
     */
    public static void replace ( List<AvPair> pairs, AvPair rep ) {
        remove(pairs, rep.getType());
        pairs.add(rep);
    }